dataply 0.0.26-alpha.5 → 0.0.26-alpha.7

package/dist/cjs/index.js

@@ -5026,32 +5026,73 @@ var BPTreePureSync = class {
       createNode(leaf, keys, values, parent = null, next = null, prev = null) {
         const id = strategy.id(leaf);
         const node = { id, keys, values, leaf, parent, next, prev };
-        strategy.write(id, node);
+        return node;
+      },
+      updateNode() {
+      },
+      deleteNode() {
+      },
+      readHead() {
+        return strategy.readHead();
+      },
+      writeHead() {
+      }
+    };
+  }
+  _createBufferedOps() {
+    const strategy = this.strategy;
+    const writeBuffer = /* @__PURE__ */ new Map();
+    const deleteBuffer = /* @__PURE__ */ new Set();
+    let headBuffer = null;
+    const ops = {
+      getNode(id) {
+        const buffered = writeBuffer.get(id);
+        if (buffered) return buffered;
+        return strategy.read(id);
+      },
+      createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+        const id = strategy.id(leaf);
+        const node = { id, keys, values, leaf, parent, next, prev };
+        writeBuffer.set(id, node);
         return node;
       },
       updateNode(node) {
-        strategy.write(node.id, node);
+        writeBuffer.set(node.id, node);
       },
       deleteNode(node) {
-        strategy.delete(node.id);
+        deleteBuffer.add(node.id);
+        writeBuffer.delete(node.id);
       },
       readHead() {
+        if (headBuffer) return headBuffer;
         return strategy.readHead();
       },
       writeHead(head) {
-        strategy.writeHead(head);
+        headBuffer = head;
       }
     };
+    function flush() {
+      for (const id of deleteBuffer) {
+        strategy.delete(id);
+      }
+      for (const [id, node] of writeBuffer) {
+        strategy.write(id, node);
+      }
+      if (headBuffer) {
+        strategy.writeHead(headBuffer);
+      }
+    }
+    return { ops, flush };
   }
   init() {
-    this._ops = this._createOps();
+    const { ops, flush } = this._createBufferedOps();
     this._ctx = {
       rootId: "",
       order: this.strategy.order,
       headData: () => this.strategy.head.data
     };
     initOp(
-      this._ops,
+      ops,
       this._ctx,
       this.strategy.order,
       this.strategy.head,
@@ -5059,6 +5100,8 @@ var BPTreePureSync = class {
         this.strategy.head = head;
       }
     );
+    flush();
+    this._ops = this._createOps();
   }
   /**
    * Returns the ID of the root node.
@@ -5132,16 +5175,24 @@ var BPTreePureSync = class {
   }
   // ─── Mutation ────────────────────────────────────────────────────
   insert(key, value) {
-    insertOp(this._ops, this._ctx, key, value, this.comparator);
+    const { ops, flush } = this._createBufferedOps();
+    insertOp(ops, this._ctx, key, value, this.comparator);
+    flush();
   }
   delete(key, value) {
-    deleteOp(this._ops, this._ctx, key, this.comparator, value);
+    const { ops, flush } = this._createBufferedOps();
+    deleteOp(ops, this._ctx, key, this.comparator, value);
+    flush();
   }
   batchInsert(entries) {
-    batchInsertOp(this._ops, this._ctx, entries, this.comparator);
+    const { ops, flush } = this._createBufferedOps();
+    batchInsertOp(ops, this._ctx, entries, this.comparator);
+    flush();
   }
   bulkLoad(entries) {
-    bulkLoadOp(this._ops, this._ctx, entries, this.comparator);
+    const { ops, flush } = this._createBufferedOps();
+    bulkLoadOp(ops, this._ctx, entries, this.comparator);
+    flush();
   }
   // ─── Head Data ───────────────────────────────────────────────────
   getHeadData() {
@@ -5152,15 +5203,17 @@ var BPTreePureSync = class {
     return head.data;
   }
   setHeadData(data) {
-    const head = this._ops.readHead();
+    const { ops, flush } = this._createBufferedOps();
+    const head = ops.readHead();
     if (head === null) {
       throw new Error("Head not found");
     }
-    this._ops.writeHead({
+    ops.writeHead({
       root: head.root,
       order: head.order,
       data
     });
+    flush();
   }
   // ─── Static utilities ────────────────────────────────────────────
   static ChooseDriver = BPTreeTransaction.ChooseDriver;
@@ -5169,6 +5222,7 @@ var BPTreePureAsync = class {
   strategy;
   comparator;
   option;
+  lock = new Ryoiki2();
   _cachedRegexp = /* @__PURE__ */ new Map();
   _ctx;
   _ops;
@@ -5194,39 +5248,93 @@ var BPTreePureAsync = class {
       async createNode(leaf, keys, values, parent = null, next = null, prev = null) {
         const id = await strategy.id(leaf);
         const node = { id, keys, values, leaf, parent, next, prev };
-        await strategy.write(id, node);
+        return node;
+      },
+      async updateNode() {
+      },
+      async deleteNode() {
+      },
+      async readHead() {
+        return await strategy.readHead();
+      },
+      async writeHead() {
+      }
+    };
+  }
+  _createBufferedOps() {
+    const strategy = this.strategy;
+    const writeBuffer = /* @__PURE__ */ new Map();
+    const deleteBuffer = /* @__PURE__ */ new Set();
+    let headBuffer = null;
+    const ops = {
+      async getNode(id) {
+        const buffered = writeBuffer.get(id);
+        if (buffered) return buffered;
+        return await strategy.read(id);
+      },
+      async createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+        const id = await strategy.id(leaf);
+        const node = { id, keys, values, leaf, parent, next, prev };
+        writeBuffer.set(id, node);
         return node;
       },
       async updateNode(node) {
-        await strategy.write(node.id, node);
+        writeBuffer.set(node.id, node);
       },
       async deleteNode(node) {
-        await strategy.delete(node.id);
+        deleteBuffer.add(node.id);
+        writeBuffer.delete(node.id);
       },
       async readHead() {
+        if (headBuffer) return headBuffer;
         return await strategy.readHead();
       },
       async writeHead(head) {
-        await strategy.writeHead(head);
+        headBuffer = head;
       }
     };
+    async function flush() {
+      for (const id of deleteBuffer) {
+        await strategy.delete(id);
+      }
+      for (const [id, node] of writeBuffer) {
+        await strategy.write(id, node);
+      }
+      if (headBuffer) {
+        await strategy.writeHead(headBuffer);
+      }
+    }
+    return { ops, flush };
+  }
+  async writeLock(fn) {
+    let lockId;
+    return this.lock.writeLock(async (_lockId) => {
+      lockId = _lockId;
+      return fn();
+    }).finally(() => {
+      this.lock.writeUnlock(lockId);
+    });
   }
   async init() {
-    this._ops = this._createOps();
-    this._ctx = {
-      rootId: "",
-      order: this.strategy.order,
-      headData: () => this.strategy.head.data
-    };
-    await initOpAsync(
-      this._ops,
-      this._ctx,
-      this.strategy.order,
-      this.strategy.head,
-      (head) => {
-        this.strategy.head = head;
-      }
-    );
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      this._ctx = {
+        rootId: "",
+        order: this.strategy.order,
+        headData: () => this.strategy.head.data
+      };
+      await initOpAsync(
+        ops,
+        this._ctx,
+        this.strategy.order,
+        this.strategy.head,
+        (head) => {
+          this.strategy.head = head;
+        }
+      );
+      await flush();
+      this._ops = this._createOps();
+    });
   }
   getRootId() {
     return this._ctx.rootId;
@@ -5250,28 +5358,40 @@ var BPTreePureAsync = class {
     return existsOpAsync(this._ops, this._ctx.rootId, key, value, this.comparator);
   }
   async *keysStream(condition, options) {
-    yield* keysStreamOpAsync(
-      this._ops,
-      this._ctx.rootId,
-      condition,
-      this.comparator,
-      this._verifierMap,
-      this._searchConfigs,
-      this._ensureValues,
-      options
-    );
+    let lockId;
+    try {
+      lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      yield* keysStreamOpAsync(
+        this._ops,
+        this._ctx.rootId,
+        condition,
+        this.comparator,
+        this._verifierMap,
+        this._searchConfigs,
+        this._ensureValues,
+        options
+      );
+    } finally {
+      if (lockId) this.lock.readUnlock(lockId);
+    }
   }
   async *whereStream(condition, options) {
-    yield* whereStreamOpAsync(
-      this._ops,
-      this._ctx.rootId,
-      condition,
-      this.comparator,
-      this._verifierMap,
-      this._searchConfigs,
-      this._ensureValues,
-      options
-    );
+    let lockId;
+    try {
+      lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      yield* whereStreamOpAsync(
+        this._ops,
+        this._ctx.rootId,
+        condition,
+        this.comparator,
+        this._verifierMap,
+        this._searchConfigs,
+        this._ensureValues,
+        options
+      );
+    } finally {
+      if (lockId) this.lock.readUnlock(lockId);
+    }
   }
   async keys(condition, options) {
     const set = /* @__PURE__ */ new Set();
@@ -5289,16 +5409,32 @@ var BPTreePureAsync = class {
   }
   // ─── Mutation ────────────────────────────────────────────────────
   async insert(key, value) {
-    await insertOpAsync(this._ops, this._ctx, key, value, this.comparator);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      await insertOpAsync(ops, this._ctx, key, value, this.comparator);
+      await flush();
+    });
   }
   async delete(key, value) {
-    await deleteOpAsync(this._ops, this._ctx, key, this.comparator, value);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      await deleteOpAsync(ops, this._ctx, key, this.comparator, value);
+      await flush();
+    });
   }
   async batchInsert(entries) {
-    await batchInsertOpAsync(this._ops, this._ctx, entries, this.comparator);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      await batchInsertOpAsync(ops, this._ctx, entries, this.comparator);
+      await flush();
+    });
   }
   async bulkLoad(entries) {
-    await bulkLoadOpAsync(this._ops, this._ctx, entries, this.comparator);
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      await bulkLoadOpAsync(ops, this._ctx, entries, this.comparator);
+      await flush();
+    });
   }
   // ─── Head Data ───────────────────────────────────────────────────
   async getHeadData() {
@@ -5307,9 +5443,13 @@ var BPTreePureAsync = class {
     return head.data;
   }
   async setHeadData(data) {
-    const head = await this._ops.readHead();
-    if (head === null) throw new Error("Head not found");
-    await this._ops.writeHead({ root: head.root, order: head.order, data });
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const head = await ops.readHead();
+      if (head === null) throw new Error("Head not found");
+      await ops.writeHead({ root: head.root, order: head.order, data });
+      await flush();
+    });
   }
   // ─── Static utilities ────────────────────────────────────────────
   static ChooseDriver = BPTreeTransaction.ChooseDriver;
@@ -9553,45 +9693,27 @@ var WALManager = class {
 
 // src/core/PageMVCCStrategy.ts
 var import_node_fs2 = __toESM(require("node:fs"));
-var PageMVCCStrategy = class {
-  constructor(fileHandle, pageSize, cacheCapacity) {
+var PageMVCCStrategy = class extends AsyncMVCCStrategy2 {
+  constructor(fileHandle, pageSize) {
+    super();
     this.fileHandle = fileHandle;
     this.pageSize = pageSize;
-    this.cache = new LRUMap2(cacheCapacity);
     this.fileSize = import_node_fs2.default.fstatSync(fileHandle).size;
   }
-  /** LRU 캐시 (페이지 ID -> 페이지 데이터) */
-  cache;
-  /** 디스크에 기록되지 않은 변경된 페이지들 (페이지 ID -> 페이지 데이터) */
-  dirtyPages = /* @__PURE__ */ new Map();
   /** 파일 크기 (논리적) */
   fileSize;
   /**
    * 디스크에서 페이지를 읽습니다.
-   * 캐시에 있으면 캐시에서 반환합니다.
    * @param pageId 페이지 ID
    * @returns 페이지 데이터
    */
   async read(pageId) {
-    const dirty = this.dirtyPages.get(pageId);
-    if (dirty) {
-      const copy = new Uint8Array(this.pageSize);
-      copy.set(dirty);
-      return copy;
-    }
-    const cached = this.cache.get(pageId);
-    if (cached) {
-      return cached;
-    }
     const buffer = new Uint8Array(this.pageSize);
     const pageStartPos = pageId * this.pageSize;
     if (pageStartPos >= this.fileSize) {
       return buffer;
     }
     await this._readFromDisk(buffer, pageStartPos);
-    const cacheCopy = new Uint8Array(this.pageSize);
-    cacheCopy.set(buffer);
-    this.cache.set(pageId, cacheCopy);
     return buffer;
   }
   /**
@@ -9601,47 +9723,27 @@ var PageMVCCStrategy = class {
    */
   async write(pageId, data) {
     const pageStartPos = pageId * this.pageSize;
-    const dataCopy = new Uint8Array(this.pageSize);
-    dataCopy.set(data);
-    this.dirtyPages.set(pageId, dataCopy);
-    this.cache.set(pageId, dataCopy);
+    await this._writeToDisk(data, pageStartPos);
     const endPosition = pageStartPos + this.pageSize;
     if (endPosition > this.fileSize) {
       this.fileSize = endPosition;
     }
   }
   /**
-   * 더티 페이지들을 메인 디스크 파일에 일괄 기록합니다.
-   * WAL 체크포인트 시점에 호출되어야 합니다.
+   * 페이지 삭제.
+   * 실제 페이지 해제는 상위 레이어(FreeList)에서 관리합니다.
+   * @param pageId 페이지 ID
    */
-  async flush() {
-    if (this.dirtyPages.size === 0) {
-      return;
-    }
-    const snapshot = new Map(this.dirtyPages);
-    const sortedPageIds = Array.from(snapshot.keys()).sort((a, b) => a - b);
-    for (const pageId of sortedPageIds) {
-      const data = snapshot.get(pageId);
-      const position = pageId * this.pageSize;
-      await this._writeToDisk(data, position);
-      this.dirtyPages.delete(pageId);
-    }
+  async delete(pageId) {
   }
   /**
-   * 지정된 페이지들만 디스크에 기록합니다.
-   * WAL 없이 트랜잭션 커밋 시, 해당 트랜잭션의 dirty pages만 선택적으로 flush합니다.
-   * @param pages 기록할 페이지 맵 (PageID -> PageData)
+   * 페이지 존재 여부 확인
+   * @param pageId 페이지 ID
+   * @returns 존재하면 true
    */
-  async flushPages(pages) {
-    if (pages.size === 0) {
-      return;
-    }
-    const sortedPageIds = Array.from(pages.keys()).sort((a, b) => a - b);
-    for (const pageId of sortedPageIds) {
-      const data = pages.get(pageId);
-      const position = pageId * this.pageSize;
-      await this._writeToDisk(data, position);
-    }
+  async exists(pageId) {
+    const pageStartPos = pageId * this.pageSize;
+    return pageStartPos < this.fileSize;
   }
   /**
    * 메인 DB 파일의 물리적 동기화를 수행합니다 (fsync).
@@ -9654,39 +9756,12 @@ var PageMVCCStrategy = class {
       });
     });
   }
-  /**
-   * 페이지 삭제 (실제로는 캐시에서만 제거)
-   * 실제 페이지 해제는 상위 레이어(FreeList)에서 관리합니다.
-   * @param pageId 페이지 ID
-   */
-  async delete(pageId) {
-    this.dirtyPages.delete(pageId);
-    this.cache.delete(pageId);
-  }
-  /**
-   * 페이지 존재 여부 확인
-   * @param pageId 페이지 ID
-   * @returns 존재하면 true
-   */
-  async exists(pageId) {
-    if (this.dirtyPages.has(pageId)) {
-      return true;
-    }
-    const pageStartPos = pageId * this.pageSize;
-    return pageStartPos < this.fileSize;
-  }
   /**
    * 현재 파일 크기 반환
    */
   getFileSize() {
     return this.fileSize;
   }
-  /**
-   * 캐시 초기화
-   */
-  clearCache() {
-    this.cache.clear();
-  }
   // ─────────────────────────────────────────────────────────────
   // Private helpers
   // ─────────────────────────────────────────────────────────────
@@ -9722,13 +9797,15 @@ var PageFileSystem = class {
     const walPath = options.wal;
     this.walManager = walPath && walLogger ? new WALManager(walPath, pageSize, walLogger) : null;
     this.pageManagerFactory = new PageManagerFactory();
-    this.pageStrategy = new PageMVCCStrategy(fileHandle, pageSize, pageCacheCapacity);
+    this.pageStrategy = new PageMVCCStrategy(fileHandle, pageSize);
+    this.rootTransaction = new AsyncMVCCTransaction2(this.pageStrategy, { cacheCapacity: pageCacheCapacity });
     this.logger = logger;
   }
   pageFactory = new PageManagerFactory();
   walManager;
   pageManagerFactory;
   pageStrategy;
+  rootTransaction;
   logger;
   /** 글로벌 동기화(체크포인트/커밋)를 위한 Mutex */
   lockPromise = Promise.resolve();
@@ -9769,6 +9846,12 @@ var PageFileSystem = class {
   getPageStrategy() {
     return this.pageStrategy;
   }
+  /**
+   * Returns the root MVCC transaction.
+   */
+  getRootTransaction() {
+    return this.rootTransaction;
+  }
   /**
    * Updates the bitmap status for a specific page.
    * @param pageId The ID of the page to update
@@ -9824,11 +9907,7 @@ var PageFileSystem = class {
    * @returns 페이지 버퍼
    */
   async get(pageIndex, tx) {
-    const page = await tx.readPage(pageIndex);
-    if (page === null) {
-      return new Uint8Array(this.pageSize);
-    }
-    return page;
+    return tx.__readPage(pageIndex);
   }
   /**
    * Reads the page header.
@@ -9919,7 +9998,7 @@ var PageFileSystem = class {
     const manager = this.pageFactory.getManager(page);
     manager.updateChecksum(page);
     await tx.__acquireWriteLock(pageIndex);
-    await tx.writePage(pageIndex, page);
+    await tx.__writePage(pageIndex, page);
   }
   /**
    * Appends and inserts a new page.
@@ -10066,27 +10145,14 @@ var PageFileSystem = class {
     metadataManager.setFreePageId(metadata, pageId);
     await this.setPage(0, metadata, tx);
   }
-  /**
-   * WAL에 커밋합니다.
-   * @param dirtyPages 변경된 페이지들
-   */
-  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);
-    }
-  }
   /**
    * 체크포인트를 수행합니다.
-   * 1. 메모리의 더티 페이지를 DB 파일에 기록 (Flush)
-   * 2. DB 파일 물리적 동기화 (Sync/fsync)
-   * 3. WAL 로그 파일 비우기 (Clear/Truncate)
+   * 1. DB 파일 물리적 동기화 (Sync/fsync)
+   * 2. WAL 로그 파일 비우기 (Clear/Truncate)
    */
   async checkpoint() {
     this.logger.info("Starting checkpoint");
     await this.runGlobalLock(async () => {
-      await this.pageStrategy.flush();
       await this.pageStrategy.sync();
       if (this.walManager) {
         await this.walManager.clear();
@@ -10891,17 +10957,16 @@ var Transaction = class {
   /**
    * @param id Transaction ID
    * @param context Transaction context
-   * @param pageStrategy Page MVCC Strategy for disk I/O
+   * @param rootTx Root MVCC Transaction
    * @param lockManager LockManager instance
    * @param pfs Page File System
-   * @param reloadBPTree Callback to reload BPTree cache on rollback
    */
-  constructor(id, context, pageStrategy, lockManager, pfs) {
+  constructor(id, context, rootTx, lockManager, pfs) {
     this.context = context;
     this.lockManager = lockManager;
     this.pfs = pfs;
     this.id = id;
-    this.pageStrategy = pageStrategy;
+    this.rootTx = rootTx;
   }
   /** Transaction ID */
   id;
@@ -10909,16 +10974,25 @@ var Transaction = class {
   heldLocks = /* @__PURE__ */ new Set();
   /** Held page locks (PageID -> LockID) */
   pageLocks = /* @__PURE__ */ new Map();
-  /** Dirty Pages modified by the transaction: PageID -> Modified Page Buffer */
-  dirtyPages = /* @__PURE__ */ new Map();
-  /** Undo pages: PageID -> Original Page Buffer (Snapshot) */
-  undoPages = /* @__PURE__ */ new Map();
   /** List of callbacks to execute on commit */
   commitHooks = [];
-  /** Page MVCC Strategy for disk access */
-  pageStrategy;
+  /** Nested MVCC Transaction for snapshot isolation (lazy init) */
+  mvccTx = null;
+  /** Root MVCC Transaction reference */
+  rootTx;
   /** Release function for global write lock, set by DataplyAPI */
   _writeLockRelease = null;
+  /**
+   * Lazily initializes the nested MVCC transaction.
+   * This ensures the snapshot is taken at the time of first access,
+   * picking up the latest committed root version.
+   */
+  ensureMvccTx() {
+    if (!this.mvccTx) {
+      this.mvccTx = this.rootTx.createNested();
+    }
+    return this.mvccTx;
+  }
   /**
    * Registers a commit hook.
    * @param hook Function to execute
@@ -10940,30 +11014,35 @@ var Transaction = class {
     return this._writeLockRelease !== null;
   }
   /**
-   * Reads a page. Uses dirty buffer if available, otherwise disk.
+   * Reads a page through the MVCC transaction.
    * @param pageId Page ID
    * @returns Page data
    */
-  async readPage(pageId) {
-    const dirty = this.dirtyPages.get(pageId);
-    if (dirty) {
-      return dirty;
+  async __readPage(pageId) {
+    const tx = this.ensureMvccTx();
+    const data = await tx.read(pageId);
+    if (data === null) {
+      return new Uint8Array(this.pfs.pageSize);
     }
-    return await this.pageStrategy.read(pageId);
+    const copy = new Uint8Array(data.length);
+    copy.set(data);
+    return copy;
   }
   /**
-   * Writes a page to the transaction buffer.
+   * Writes a page through the MVCC transaction.
    * @param pageId Page ID
    * @param data Page data
    */
-  async writePage(pageId, data) {
-    if (!this.undoPages.has(pageId)) {
-      const existingData = await this.pageStrategy.read(pageId);
-      const snapshot = new Uint8Array(existingData.length);
-      snapshot.set(existingData);
-      this.undoPages.set(pageId, snapshot);
+  async __writePage(pageId, data) {
+    const tx = this.ensureMvccTx();
+    const exists = await tx.exists(pageId);
+    if (exists) {
+      const copy = new Uint8Array(data.length);
+      copy.set(data);
+      await tx.write(pageId, copy);
+    } else {
+      await tx.create(pageId, data);
     }
-    this.dirtyPages.set(pageId, data);
   }
   /**
    * Acquires a write lock.
@@ -10990,21 +11069,31 @@ var Transaction = class {
           await hook();
         }
       });
+      const tx = this.ensureMvccTx();
       let shouldTriggerCheckpoint = false;
       await this.pfs.runGlobalLock(async () => {
-        if (this.pfs.wal && this.dirtyPages.size > 0) {
-          await this.pfs.wal.prepareCommit(this.dirtyPages);
+        const entries = tx.getResultEntries();
+        const dirtyPages = /* @__PURE__ */ new Map();
+        for (const entry of [...entries.created, ...entries.updated]) {
+          dirtyPages.set(entry.key, entry.data);
+        }
+        const hasDirtyPages = dirtyPages.size > 0;
+        if (this.pfs.wal && hasDirtyPages) {
+          await this.pfs.wal.prepareCommit(dirtyPages);
           await this.pfs.wal.writeCommitMarker();
         }
-        for (const [pageId, data] of this.dirtyPages) {
-          await this.pageStrategy.write(pageId, data);
+        await tx.commit();
+        if (hasDirtyPages) {
+          await this.rootTx.commit();
         }
-        if (!this.pfs.wal) {
-          await this.pfs.strategy.flushPages(this.dirtyPages);
-        } else {
-          this.pfs.wal.incrementWrittenPages(this.dirtyPages.size);
-          if (this.pfs.wal.shouldCheckpoint(this.pfs.options.walCheckpointThreshold)) {
-            shouldTriggerCheckpoint = true;
+        if (hasDirtyPages) {
+          if (!this.pfs.wal) {
+            await this.pfs.strategy.sync();
+          } else {
+            this.pfs.wal.incrementWrittenPages(dirtyPages.size);
+            if (this.pfs.wal.shouldCheckpoint(this.pfs.options.walCheckpointThreshold)) {
+              shouldTriggerCheckpoint = true;
+            }
           }
         }
       });
@@ -11012,8 +11101,6 @@ var Transaction = class {
         await this.pfs.checkpoint();
       }
     } finally {
-      this.dirtyPages.clear();
-      this.undoPages.clear();
       this.releaseAllLocks();
       if (this._writeLockRelease) {
         this._writeLockRelease();
@@ -11026,8 +11113,9 @@ var Transaction = class {
    */
   async rollback() {
     try {
-      this.dirtyPages.clear();
-      this.undoPages.clear();
+      if (this.mvccTx) {
+        this.mvccTx.rollback();
+      }
       this.releaseAllLocks();
     } finally {
       if (this._writeLockRelease) {
@@ -11036,12 +11124,6 @@ var Transaction = class {
       }
     }
   }
-  /**
-   * Returns the dirty pages map.
-   */
-  __getDirtyPages() {
-    return this.dirtyPages;
-  }
   /**
    * Releases all locks.
    */
@@ -11213,7 +11295,7 @@ var DataplyAPI = class {
       pagePreallocationCount: 1e3,
       wal: null,
       walCheckpointThreshold: 1e3,
-      logLevel: 2 /* Info */
+      logLevel: 0 /* None */
     }, options);
   }
   /**
@@ -11334,7 +11416,7 @@ var DataplyAPI = class {
     return new Transaction(
       ++this.txIdCounter,
       this.txContext,
-      this.pfs.getPageStrategy(),
+      this.pfs.getRootTransaction(),
       this.lockManager,
       this.pfs
     );
@@ -11354,7 +11436,7 @@ var DataplyAPI = class {
    * Used internally by runWithDefaultWrite.
    * @returns A release function
    */
-  acquireWriteLock() {
+  async acquireWriteLock() {
     this.logger.debug("Acquiring write lock");
     const previous = this.writeQueue;
     let release;

package/dist/types/core/PageFileSystem.d.ts

@@ -1,5 +1,6 @@
 import type { IndexPage, MetadataPage, DataplyOptions } from '../types';
 import type { Transaction } from './transaction/Transaction';
+import { AsyncMVCCTransaction } from 'mvcc-api';
 import { PageManagerFactory } from './Page';
 import { WALManager } from './WALManager';
 import { PageMVCCStrategy } from './PageMVCCStrategy';
@@ -17,6 +18,7 @@ export declare class PageFileSystem {
     protected readonly walManager: WALManager | null;
     protected readonly pageManagerFactory: PageManagerFactory;
     protected readonly pageStrategy: PageMVCCStrategy;
+    protected readonly rootTransaction: AsyncMVCCTransaction<PageMVCCStrategy, number, Uint8Array>;
     protected readonly logger: Logger;
     /** 글로벌 동기화(체크포인트/커밋)를 위한 Mutex */
     private lockPromise;
@@ -39,6 +41,10 @@ export declare class PageFileSystem {
      * Returns the page strategy for transaction use.
      */
     getPageStrategy(): PageMVCCStrategy;
+    /**
+     * Returns the root MVCC transaction.
+     */
+    getRootTransaction(): AsyncMVCCTransaction<PageMVCCStrategy, number, Uint8Array>;
     /**
      * Updates the bitmap status for a specific page.
      * @param pageId The ID of the page to update
@@ -134,16 +140,10 @@ export declare class PageFileSystem {
      * @param tx Transaction
      */
     setFreePage(pageId: number, tx: Transaction): Promise<void>;
-    /**
-     * WAL에 커밋합니다.
-     * @param dirtyPages 변경된 페이지들
-     */
-    commitToWAL(dirtyPages: Map<number, Uint8Array>): Promise<void>;
     /**
      * 체크포인트를 수행합니다.
-     * 1. 메모리의 더티 페이지를 DB 파일에 기록 (Flush)
-     * 2. DB 파일 물리적 동기화 (Sync/fsync)
-     * 3. WAL 로그 파일 비우기 (Clear/Truncate)
+     * 1. DB 파일 물리적 동기화 (Sync/fsync)
+     * 2. WAL 로그 파일 비우기 (Clear/Truncate)
      */
     checkpoint(): Promise<void>;
     /**

package/dist/types/core/PageMVCCStrategy.d.ts

@@ -1,23 +1,20 @@
+import { AsyncMVCCStrategy } from 'mvcc-api';
 /**
  * 페이지 수준 MVCC Strategy.
  * mvcc-api의 AsyncMVCCStrategy를 상속하여 디스크 I/O를 담당합니다.
+ * 캐시 및 버퍼 관리는 mvcc-api의 AsyncMVCCTransaction이 담당합니다.
  *
  * 키: 페이지 ID (number)
  * 값: 페이지 데이터 (Uint8Array)
  */
-export declare class PageMVCCStrategy {
+export declare class PageMVCCStrategy extends AsyncMVCCStrategy<number, Uint8Array> {
     private readonly fileHandle;
     private readonly pageSize;
-    /** LRU 캐시 (페이지 ID -> 페이지 데이터) */
-    private readonly cache;
-    /** 디스크에 기록되지 않은 변경된 페이지들 (페이지 ID -> 페이지 데이터) */
-    private readonly dirtyPages;
     /** 파일 크기 (논리적) */
     private fileSize;
-    constructor(fileHandle: number, pageSize: number, cacheCapacity: number);
+    constructor(fileHandle: number, pageSize: number);
     /**
      * 디스크에서 페이지를 읽습니다.
-     * 캐시에 있으면 캐시에서 반환합니다.
      * @param pageId 페이지 ID
      * @returns 페이지 데이터
      */
@@ -29,22 +26,7 @@ export declare class PageMVCCStrategy {
      */
     write(pageId: number, data: Uint8Array): Promise<void>;
     /**
-     * 더티 페이지들을 메인 디스크 파일에 일괄 기록합니다.
-     * WAL 체크포인트 시점에 호출되어야 합니다.
-     */
-    flush(): Promise<void>;
-    /**
-     * 지정된 페이지들만 디스크에 기록합니다.
-     * WAL 없이 트랜잭션 커밋 시, 해당 트랜잭션의 dirty pages만 선택적으로 flush합니다.
-     * @param pages 기록할 페이지 맵 (PageID -> PageData)
-     */
-    flushPages(pages: Map<number, Uint8Array>): Promise<void>;
-    /**
-     * 메인 DB 파일의 물리적 동기화를 수행합니다 (fsync).
-     */
-    sync(): Promise<void>;
-    /**
-     * 페이지 삭제 (실제로는 캐시에서만 제거)
+     * 페이지 삭제.
      * 실제 페이지 해제는 상위 레이어(FreeList)에서 관리합니다.
      * @param pageId 페이지 ID
      */
@@ -56,13 +38,13 @@ export declare class PageMVCCStrategy {
      */
     exists(pageId: number): Promise<boolean>;
     /**
-     * 현재 파일 크기 반환
+     * 메인 DB 파일의 물리적 동기화를 수행합니다 (fsync).
      */
-    getFileSize(): number;
+    sync(): Promise<void>;
     /**
-     * 캐시 초기화
+     * 현재 파일 크기 반환
      */
-    clearCache(): void;
+    getFileSize(): number;
     private _readFromDisk;
     private _writeToDisk;
 }

package/dist/types/core/transaction/Transaction.d.ts

@@ -1,10 +1,12 @@
 import type { PageFileSystem } from '../PageFileSystem';
+import type { AsyncMVCCTransaction } from 'mvcc-api';
+import type { PageMVCCStrategy } from '../PageMVCCStrategy';
 import { LockManager } from './LockManager';
 import { TransactionContext } from './TxContext';
-import { PageMVCCStrategy } from '../PageMVCCStrategy';
 /**
  * Transaction class.
  * Manages the lifecycle and resources of a database transaction.
+ * Internally wraps a nested AsyncMVCCTransaction for snapshot isolation.
  */
 export declare class Transaction {
     readonly context: TransactionContext;
@@ -16,25 +18,28 @@ export declare class Transaction {
     private heldLocks;
     /** Held page locks (PageID -> LockID) */
     private pageLocks;
-    /** Dirty Pages modified by the transaction: PageID -> Modified Page Buffer */
-    private dirtyPages;
-    /** Undo pages: PageID -> Original Page Buffer (Snapshot) */
-    private undoPages;
     /** List of callbacks to execute on commit */
     private commitHooks;
-    /** Page MVCC Strategy for disk access */
-    private readonly pageStrategy;
+    /** Nested MVCC Transaction for snapshot isolation (lazy init) */
+    private mvccTx;
+    /** Root MVCC Transaction reference */
+    private readonly rootTx;
     /** Release function for global write lock, set by DataplyAPI */
     private _writeLockRelease;
     /**
      * @param id Transaction ID
      * @param context Transaction context
-     * @param pageStrategy Page MVCC Strategy for disk I/O
+     * @param rootTx Root MVCC Transaction
      * @param lockManager LockManager instance
      * @param pfs Page File System
-     * @param reloadBPTree Callback to reload BPTree cache on rollback
      */
-    constructor(id: number, context: TransactionContext, pageStrategy: PageMVCCStrategy, lockManager: LockManager, pfs: PageFileSystem);
+    constructor(id: number, context: TransactionContext, rootTx: AsyncMVCCTransaction<PageMVCCStrategy, number, Uint8Array>, lockManager: LockManager, pfs: PageFileSystem);
+    /**
+     * Lazily initializes the nested MVCC transaction.
+     * This ensures the snapshot is taken at the time of first access,
+     * picking up the latest committed root version.
+     */
+    private ensureMvccTx;
     /**
      * Registers a commit hook.
      * @param hook Function to execute
@@ -50,17 +55,17 @@ export declare class Transaction {
      */
     __hasWriteLockRelease(): boolean;
     /**
-     * Reads a page. Uses dirty buffer if available, otherwise disk.
+     * Reads a page through the MVCC transaction.
      * @param pageId Page ID
      * @returns Page data
      */
-    readPage(pageId: number): Promise<Uint8Array>;
+    __readPage(pageId: number): Promise<Uint8Array>;
     /**
-     * Writes a page to the transaction buffer.
+     * Writes a page through the MVCC transaction.
      * @param pageId Page ID
      * @param data Page data
      */
-    writePage(pageId: number, data: Uint8Array): Promise<void>;
+    __writePage(pageId: number, data: Uint8Array): Promise<void>;
     /**
      * Acquires a write lock.
      * @param pageId Page ID
@@ -74,10 +79,6 @@ export declare class Transaction {
      * Rolls back the transaction.
      */
     rollback(): Promise<void>;
-    /**
-     * Returns the dirty pages map.
-     */
-    __getDirtyPages(): Map<number, Uint8Array>;
     /**
      * Releases all locks.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.26-alpha.5",
+  "version": "0.0.26-alpha.7",
   "description": "A lightweight storage engine for Node.js with support for MVCC, WAL.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -49,6 +49,6 @@
     "hookall": "^2.2.0",
     "mvcc-api": "^1.3.7",
     "ryoiki": "^1.2.0",
-    "serializable-bptree": "^9.0.0"
+    "serializable-bptree": "^9.0.1"
   }
-}
+}