dataply 0.0.17-alpha.0 → 0.0.17-alpha.1

package/dist/cjs/index.js

@@ -30,6 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  AsyncMVCCStrategy: () => AsyncMVCCStrategy2,
+  AsyncMVCCTransaction: () => AsyncMVCCTransaction2,
   BPTreeAsync: () => BPTreeAsync,
   BPTreeAsyncTransaction: () => BPTreeAsyncTransaction,
   BPTreeSync: () => BPTreeSync,
@@ -47,6 +49,8 @@ __export(src_exports, {
   IndexPageManager: () => IndexPageManager,
   InvertedWeakMap: () => InvertedWeakMap,
   LRUMap: () => LRUMap2,
+  MVCCStrategy: () => MVCCStrategy2,
+  MVCCTransaction: () => MVCCTransaction2,
   MetadataPageManager: () => MetadataPageManager,
   NumericComparator: () => NumericComparator,
   OverflowPageManager: () => OverflowPageManager,
@@ -56,6 +60,8 @@ __export(src_exports, {
   SerializeStrategyAsync: () => SerializeStrategyAsync,
   SerializeStrategySync: () => SerializeStrategySync,
   StringComparator: () => StringComparator,
+  SyncMVCCStrategy: () => SyncMVCCStrategy2,
+  SyncMVCCTransaction: () => SyncMVCCTransaction2,
   Transaction: () => Transaction,
   UnknownPageManager: () => UnknownPageManager,
   ValueComparator: () => ValueComparator
@@ -4561,6 +4567,1125 @@ var InvertedWeakMap = class {
   }
 };
 
+// node_modules/mvcc-api/dist/esm/index.mjs
+var MVCCStrategy2 = class {
+};
+var MVCCTransaction2 = class {
+  committed;
+  snapshotVersion;
+  snapshotLocalVersion;
+  writeBuffer;
+  deleteBuffer;
+  createdKeys;
+  // create()로 생성된 키 추적
+  deletedValues;
+  // delete 시 삭제 전 값 저장
+  originallyExisted;
+  // 트랜잭션 시작 시점에 디스크에 존재했던 키 (deleted 결과 필터링용)
+  // Nested Transaction Properties
+  parent;
+  localVersion;
+  // Local version for Nested Conflict Detection
+  keyVersions;
+  // Key -> Local Version (When it was modified locally)
+  // Root Transaction Properties (Only populated if this is Root)
+  root;
+  strategy;
+  version = 0;
+  versionIndex = /* @__PURE__ */ new Map();
+  deletedCache = /* @__PURE__ */ new Map();
+  activeTransactions = /* @__PURE__ */ new Set();
+  constructor(strategy, parent, snapshotVersion) {
+    this.snapshotVersion = snapshotVersion ?? 0;
+    this.writeBuffer = /* @__PURE__ */ new Map();
+    this.deleteBuffer = /* @__PURE__ */ new Set();
+    this.createdKeys = /* @__PURE__ */ new Set();
+    this.deletedValues = /* @__PURE__ */ new Map();
+    this.originallyExisted = /* @__PURE__ */ new Set();
+    this.committed = false;
+    this.parent = parent;
+    this.keyVersions = /* @__PURE__ */ new Map();
+    if (parent) {
+      this.localVersion = parent.localVersion;
+      this.snapshotLocalVersion = parent.localVersion;
+      this.strategy = void 0;
+      this.root = parent.root;
+    } else {
+      if (!strategy) throw new Error("Root Transaction must get Strategy");
+      this.strategy = strategy;
+      this.version = 0;
+      this.localVersion = 0;
+      this.snapshotLocalVersion = 0;
+      this.root = this;
+    }
+  }
+  isRoot() {
+    return !this.parent;
+  }
+  /**
+   * Checks if any ancestor transaction has already been committed.
+   * A nested transaction cannot commit if its parent or any higher ancestor is committed.
+   * @returns True if at least one ancestor is committed, false otherwise.
+   */
+  hasCommittedAncestor() {
+    let current = this.parent;
+    while (current) {
+      if (current.committed) return true;
+      current = current.parent;
+    }
+    return false;
+  }
+  // --- Internal buffer manipulation helpers ---
+  _bufferCreate(key, value) {
+    this.localVersion++;
+    this.writeBuffer.set(key, value);
+    this.createdKeys.add(key);
+    this.deleteBuffer.delete(key);
+    this.originallyExisted.delete(key);
+    this.keyVersions.set(key, this.localVersion);
+  }
+  _bufferWrite(key, value) {
+    this.localVersion++;
+    this.writeBuffer.set(key, value);
+    this.deleteBuffer.delete(key);
+    this.keyVersions.set(key, this.localVersion);
+  }
+  _bufferDelete(key) {
+    this.localVersion++;
+    this.deleteBuffer.add(key);
+    this.writeBuffer.delete(key);
+    this.createdKeys.delete(key);
+    this.keyVersions.set(key, this.localVersion);
+  }
+  /**
+   * Returns the entries that will be created, updated, and deleted by this transaction.
+   * @returns An object containing arrays of created, updated, and deleted entries.
+   */
+  getResultEntries() {
+    const created = [];
+    const updated = [];
+    for (const [key, data] of this.writeBuffer.entries()) {
+      if (this.createdKeys.has(key)) {
+        created.push({ key, data });
+      } else {
+        updated.push({ key, data });
+      }
+    }
+    const deleted = [];
+    for (const key of this.deleteBuffer) {
+      if (!this.originallyExisted.has(key)) continue;
+      const data = this.deletedValues.get(key);
+      if (data !== void 0) {
+        deleted.push({ key, data });
+      }
+    }
+    return { created, updated, deleted };
+  }
+  /**
+   * Rolls back the transaction.
+   * Clears all buffers and marks the transaction as finished.
+   * @returns The result object with success, created, updated, and deleted keys.
+   */
+  rollback() {
+    const { created, updated, deleted } = this.getResultEntries();
+    this.writeBuffer.clear();
+    this.deleteBuffer.clear();
+    this.createdKeys.clear();
+    this.deletedValues.clear();
+    this.originallyExisted.clear();
+    this.committed = true;
+    if (this.root !== this) {
+      this.root.activeTransactions.delete(this);
+    }
+    return { success: true, created, updated, deleted };
+  }
+};
+var SyncMVCCStrategy2 = class extends MVCCStrategy2 {
+};
+var SyncMVCCTransaction2 = class _SyncMVCCTransaction2 extends MVCCTransaction2 {
+  create(key, value) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (this.writeBuffer.has(key) || !this.deleteBuffer.has(key) && this.read(key) !== null) {
+      throw new Error(`Key already exists: ${key}`);
+    }
+    this._bufferCreate(key, value);
+    return this;
+  }
+  write(key, value) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (!this.writeBuffer.has(key) && (this.deleteBuffer.has(key) || this.read(key) === null)) {
+      throw new Error(`Key not found: ${key}`);
+    }
+    this._bufferWrite(key, value);
+    return this;
+  }
+  delete(key) {
+    if (this.committed) throw new Error("Transaction already committed");
+    let valueToDelete = null;
+    let wasInWriteBuffer = false;
+    if (this.writeBuffer.has(key)) {
+      valueToDelete = this.writeBuffer.get(key);
+      wasInWriteBuffer = true;
+    } else if (!this.deleteBuffer.has(key)) {
+      valueToDelete = this.read(key);
+    }
+    if (valueToDelete === null) {
+      throw new Error(`Key not found: ${key}`);
+    }
+    this.deletedValues.set(key, valueToDelete);
+    if (!wasInWriteBuffer || !this.createdKeys.has(key)) {
+      this.originallyExisted.add(key);
+    }
+    this._bufferDelete(key);
+    return this;
+  }
+  createNested() {
+    if (this.committed) throw new Error("Transaction already committed");
+    const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
+    const child = new _SyncMVCCTransaction2(void 0, this, childVersion);
+    this.root.activeTransactions.add(child);
+    return child;
+  }
+  read(key) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
+    if (this.deleteBuffer.has(key)) return null;
+    return this.root._diskRead(key, this.snapshotVersion);
+  }
+  exists(key) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (this.deleteBuffer.has(key)) return false;
+    if (this.writeBuffer.has(key)) return true;
+    return this.root._diskExists(key, this.snapshotVersion);
+  }
+  _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+    if (this.writeBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return this.writeBuffer.get(key);
+      }
+    }
+    if (this.deleteBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return null;
+      }
+    }
+    if (this.parent) {
+      return this.parent._readSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
+    } else {
+      return this._diskRead(key, snapshotVersion);
+    }
+  }
+  commit(label) {
+    const { created, updated, deleted } = this.getResultEntries();
+    if (this.committed) {
+      return {
+        label,
+        success: false,
+        error: "Transaction already committed",
+        conflict: void 0,
+        created,
+        updated,
+        deleted
+      };
+    }
+    if (this.hasCommittedAncestor()) {
+      return {
+        label,
+        success: false,
+        error: "Ancestor transaction already committed",
+        conflict: void 0,
+        created,
+        updated,
+        deleted
+      };
+    }
+    if (this.parent) {
+      const failure = this.parent._merge(this);
+      if (failure) {
+        return {
+          label,
+          success: false,
+          error: failure.error,
+          conflict: failure.conflict,
+          created,
+          updated,
+          deleted
+        };
+      }
+      this.committed = true;
+    } else {
+      if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
+        const failure = this._merge(this);
+        if (failure) {
+          return {
+            label,
+            success: false,
+            error: failure.error,
+            conflict: failure.conflict,
+            created: [],
+            updated: [],
+            deleted: []
+          };
+        }
+        this.writeBuffer.clear();
+        this.deleteBuffer.clear();
+        this.createdKeys.clear();
+        this.deletedValues.clear();
+        this.originallyExisted.clear();
+        this.keyVersions.clear();
+        this.localVersion = 0;
+        this.snapshotVersion = this.version;
+      }
+    }
+    return {
+      label,
+      success: true,
+      created,
+      updated,
+      deleted
+    };
+  }
+  _merge(child) {
+    if (this.parent) {
+      for (const key of child.writeBuffer.keys()) {
+        const lastModLocalVer = this.keyVersions.get(key);
+        if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
+          return {
+            error: `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`,
+            conflict: {
+              key,
+              parent: this.read(key),
+              child: child.read(key)
+            }
+          };
+        }
+      }
+      for (const key of child.deleteBuffer) {
+        const lastModLocalVer = this.keyVersions.get(key);
+        if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
+          return {
+            error: `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`,
+            conflict: {
+              key,
+              parent: this.read(key),
+              child: child.read(key)
+            }
+          };
+        }
+      }
+      const newLocalVersion = this.localVersion + 1;
+      for (const key of child.writeBuffer.keys()) {
+        this.writeBuffer.set(key, child.writeBuffer.get(key));
+        this.deleteBuffer.delete(key);
+        this.keyVersions.set(key, newLocalVersion);
+        if (child.createdKeys.has(key)) {
+          this.createdKeys.add(key);
+        }
+      }
+      for (const key of child.deleteBuffer) {
+        this.deleteBuffer.add(key);
+        this.writeBuffer.delete(key);
+        this.createdKeys.delete(key);
+        this.keyVersions.set(key, newLocalVersion);
+        const deletedValue = child.deletedValues.get(key);
+        if (deletedValue !== void 0) {
+          this.deletedValues.set(key, deletedValue);
+        }
+        if (child.originallyExisted.has(key)) {
+          this.originallyExisted.add(key);
+        }
+      }
+      this.localVersion = newLocalVersion;
+      this.root.activeTransactions.delete(child);
+    } else {
+      const newVersion = this.version + 1;
+      if (child !== this) {
+        const modifiedKeys = /* @__PURE__ */ new Set([...child.writeBuffer.keys(), ...child.deleteBuffer]);
+        for (const key of modifiedKeys) {
+          const versions = this.versionIndex.get(key);
+          if (versions && versions.length > 0) {
+            const lastVer = versions[versions.length - 1].version;
+            if (lastVer > child.snapshotVersion) {
+              return {
+                error: `Commit conflict: Key '${key}' was modified by a newer transaction (v${lastVer})`,
+                conflict: {
+                  key,
+                  parent: this.read(key),
+                  child: child.read(key)
+                }
+              };
+            }
+          }
+        }
+      }
+      for (const [key, value] of child.writeBuffer) {
+        this.writeBuffer.set(key, value);
+        this.deleteBuffer.delete(key);
+        if (child.createdKeys.has(key)) {
+          this.createdKeys.add(key);
+        }
+      }
+      for (const key of child.deleteBuffer) {
+        this.deleteBuffer.add(key);
+        this.writeBuffer.delete(key);
+        this.createdKeys.delete(key);
+        const deletedValue = child.deletedValues.get(key);
+        if (deletedValue !== void 0) {
+          this.deletedValues.set(key, deletedValue);
+        }
+        if (child.originallyExisted.has(key)) {
+          this.originallyExisted.add(key);
+        }
+      }
+      for (const [key, value] of child.writeBuffer) {
+        this._diskWrite(key, value, newVersion);
+      }
+      for (const key of child.deleteBuffer) {
+        this._diskDelete(key, newVersion);
+      }
+      this.version = newVersion;
+      this.root.activeTransactions.delete(child);
+      this._cleanupDeletedCache();
+    }
+    return null;
+  }
+  // --- Internal IO Helpers (Root Only) ---
+  _diskWrite(key, value, version) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    if (strategy.exists(key)) {
+      const currentVal = strategy.read(key);
+      if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+      this.deletedCache.get(key).push({
+        value: currentVal,
+        deletedAtVersion: version
+      });
+    }
+    strategy.write(key, value);
+    if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
+    this.versionIndex.get(key).push({ version, exists: true });
+  }
+  _diskRead(key, snapshotVersion) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    const versions = this.versionIndex.get(key);
+    if (!versions) {
+      return strategy.exists(key) ? strategy.read(key) : null;
+    }
+    let targetVerObj = null;
+    let nextVerObj = null;
+    for (const v of versions) {
+      if (v.version <= snapshotVersion) {
+        targetVerObj = v;
+      } else {
+        nextVerObj = v;
+        break;
+      }
+    }
+    if (!targetVerObj) {
+      if (nextVerObj) {
+        const cached2 = this.deletedCache.get(key);
+        if (cached2) {
+          const match = cached2.find((c) => c.deletedAtVersion === nextVerObj.version);
+          if (match) return match.value;
+        }
+      }
+      return null;
+    }
+    if (!targetVerObj.exists) return null;
+    if (!nextVerObj) {
+      return strategy.read(key);
+    }
+    const cached = this.deletedCache.get(key);
+    if (cached) {
+      const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
+      if (match) return match.value;
+    }
+    return null;
+  }
+  _diskExists(key, snapshotVersion) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    const versions = this.versionIndex.get(key);
+    if (!versions) {
+      return strategy.exists(key);
+    }
+    let targetVerObj = null;
+    for (const v of versions) {
+      if (v.version <= snapshotVersion) {
+        targetVerObj = v;
+      } else {
+        break;
+      }
+    }
+    if (!targetVerObj) return strategy.exists(key);
+    return targetVerObj.exists;
+  }
+  _diskDelete(key, snapshotVersion) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    if (strategy.exists(key)) {
+      const currentVal = strategy.read(key);
+      if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+      this.deletedCache.get(key).push({
+        value: currentVal,
+        deletedAtVersion: snapshotVersion
+      });
+    }
+    strategy.delete(key);
+    if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
+    this.versionIndex.get(key).push({ version: snapshotVersion, exists: false });
+  }
+  _cleanupDeletedCache() {
+    if (this.deletedCache.size === 0) return;
+    let minActiveVersion = this.version;
+    if (this.activeTransactions.size > 0) {
+      for (const tx of this.activeTransactions) {
+        if (!tx.committed && tx.snapshotVersion < minActiveVersion) {
+          minActiveVersion = tx.snapshotVersion;
+        }
+      }
+    }
+    for (const [key, cachedList] of this.deletedCache) {
+      const remaining = cachedList.filter((item) => item.deletedAtVersion > minActiveVersion);
+      if (remaining.length === 0) {
+        this.deletedCache.delete(key);
+      } else {
+        this.deletedCache.set(key, remaining);
+      }
+    }
+  }
+};
+var AsyncMVCCStrategy2 = class extends MVCCStrategy2 {
+};
+var Ryoiki4 = class _Ryoiki4 {
+  readings;
+  writings;
+  readQueue;
+  writeQueue;
+  static async CatchError(promise) {
+    return await promise.then((v) => [void 0, v]).catch((err) => [err]);
+  }
+  static IsRangeOverlap(a, b) {
+    const [start1, end1] = a;
+    const [start2, end2] = b;
+    if (end1 <= start2 || end2 <= start1) {
+      return false;
+    }
+    return true;
+  }
+  static ERR_ALREADY_EXISTS(lockId) {
+    return new Error(`The '${lockId}' task already existing in queue or running.`);
+  }
+  static ERR_NOT_EXISTS(lockId) {
+    return new Error(`The '${lockId}' task not existing in task queue.`);
+  }
+  static ERR_TIMEOUT(lockId, timeout) {
+    return new Error(`The task with ID '${lockId}' failed to acquire the lock within the timeout(${timeout}ms).`);
+  }
+  /**
+   * Constructs a new instance of the Ryoiki class.
+   */
+  constructor() {
+    this.readings = /* @__PURE__ */ new Map();
+    this.writings = /* @__PURE__ */ new Map();
+    this.readQueue = /* @__PURE__ */ new Map();
+    this.writeQueue = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Creates a range based on a start value and length.
+   * @param start - The starting value of the range.
+   * @param length - The length of the range.
+   * @returns A range tuple [start, start + length].
+   */
+  range(start, length) {
+    return [start, start + length];
+  }
+  rangeOverlapping(tasks, range) {
+    return Array.from(tasks.values()).some((t) => _Ryoiki4.IsRangeOverlap(t.range, range));
+  }
+  isSameRange(a, b) {
+    const [a1, a2] = a;
+    const [b1, b2] = b;
+    return a1 === b1 && a2 === b2;
+  }
+  fetchUnitAndRun(queue, workspaces) {
+    for (const [id, unit] of queue) {
+      if (!unit.condition()) {
+        continue;
+      }
+      this._alloc(queue, workspaces, id);
+    }
+  }
+  _handleOverload(args, handlers, argPatterns) {
+    for (const [key, pattern] of Object.entries(argPatterns)) {
+      if (this._matchArgs(args, pattern)) {
+        return handlers[key](...args);
+      }
+    }
+    throw new Error("Invalid arguments");
+  }
+  _matchArgs(args, pattern) {
+    return args.every((arg, index) => {
+      const expectedType = pattern[index];
+      if (expectedType === void 0) return typeof arg === "undefined";
+      if (expectedType === Function) return typeof arg === "function";
+      if (expectedType === Number) return typeof arg === "number";
+      if (expectedType === Array) return Array.isArray(arg);
+      return false;
+    });
+  }
+  _createRandomId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2);
+    return `${timestamp}${random}`;
+  }
+  _alloc(queue, workspaces, lockId) {
+    const unit = queue.get(lockId);
+    if (!unit) {
+      throw _Ryoiki4.ERR_NOT_EXISTS(lockId);
+    }
+    workspaces.set(lockId, unit);
+    queue.delete(lockId);
+    unit.alloc();
+  }
+  _free(workspaces, lockId) {
+    const unit = workspaces.get(lockId);
+    if (!unit) {
+      throw _Ryoiki4.ERR_NOT_EXISTS(lockId);
+    }
+    workspaces.delete(lockId);
+    unit.free();
+  }
+  _lock(queue, range, timeout, task, condition) {
+    return new Promise((resolve, reject) => {
+      let timeoutId = null;
+      if (timeout >= 0) {
+        timeoutId = setTimeout(() => {
+          reject(_Ryoiki4.ERR_TIMEOUT(id, timeout));
+        }, timeout);
+      }
+      const id = this._createRandomId();
+      const alloc = async () => {
+        if (timeoutId !== null) {
+          clearTimeout(timeoutId);
+        }
+        const [err, v] = await _Ryoiki4.CatchError(task(id));
+        if (err) reject(err);
+        else resolve(v);
+      };
+      const fetch = () => {
+        this.fetchUnitAndRun(this.readQueue, this.readings);
+        this.fetchUnitAndRun(this.writeQueue, this.writings);
+      };
+      queue.set(id, { id, range, condition, alloc, free: fetch });
+      fetch();
+    });
+  }
+  _checkWorking(range, workspaces) {
+    let isLocked = false;
+    for (const lock of workspaces.values()) {
+      if (_Ryoiki4.IsRangeOverlap(range, lock.range)) {
+        isLocked = true;
+        break;
+      }
+    }
+    return isLocked;
+  }
+  /**
+   * Checks if there is any active read lock within the specified range.
+   * @param range The range to check for active read locks.
+   * @returns `true` if there is an active read lock within the range, `false` otherwise.
+   */
+  isReading(range) {
+    return this._checkWorking(range, this.readings);
+  }
+  /**
+   * Checks if there is any active write lock within the specified range.
+   * @param range The range to check for active write locks.
+   * @returns `true` if there is an active write lock within the range, `false` otherwise.
+   */
+  isWriting(range) {
+    return this._checkWorking(range, this.writings);
+  }
+  /**
+   * Checks if a read lock can be acquired within the specified range.
+   * @param range The range to check for read lock availability.
+   * @returns `true` if a read lock can be acquired, `false` otherwise.
+   */
+  canRead(range) {
+    const writing = this.isWriting(range);
+    return !writing;
+  }
+  /**
+   * Checks if a write lock can be acquired within the specified range.
+   * @param range The range to check for write lock availability.
+   * @returns `true` if a write lock can be acquired, `false` otherwise.
+   */
+  canWrite(range) {
+    const reading = this.isReading(range);
+    const writing = this.isWriting(range);
+    return !reading && !writing;
+  }
+  /**
+   * Internal implementation of the read lock. Handles both overloads.
+   * @template T - The return type of the task.
+   * @param arg0 - Either a range or a task callback.
+   * If a range is provided, the task is the second argument.
+   * @param arg1 - The task to execute, required if a range is provided.
+   * @param arg2 - The timeout for acquiring the lock.
+   * If the lock cannot be acquired within this period, an error will be thrown.
+   * If this value is not provided, no timeout will be set.
+   * @returns A promise resolving to the result of the task execution.
+   */
+  readLock(arg0, arg1, arg2) {
+    const [range, task, timeout] = this._handleOverload(
+      [arg0, arg1, arg2],
+      {
+        rangeTask: (range2, task2) => [range2, task2, -1],
+        rangeTaskTimeout: (range2, task2, timeout2) => [range2, task2, timeout2],
+        task: (task2) => [[-Infinity, Infinity], task2, -1],
+        taskTimeout: (task2, timeout2) => [[-Infinity, Infinity], task2, timeout2]
+      },
+      {
+        task: [Function],
+        taskTimeout: [Function, Number],
+        rangeTask: [Array, Function],
+        rangeTaskTimeout: [Array, Function, Number]
+      }
+    );
+    return this._lock(
+      this.readQueue,
+      range,
+      timeout,
+      task,
+      () => !this.rangeOverlapping(this.writings, range)
+    );
+  }
+  /**
+   * Internal implementation of the write lock. Handles both overloads.
+   * @template T - The return type of the task.
+   * @param arg0 - Either a range or a task callback.
+   * If a range is provided, the task is the second argument.
+   * @param arg1 - The task to execute, required if a range is provided.
+   * @param arg2 - The timeout for acquiring the lock.
+   * If the lock cannot be acquired within this period, an error will be thrown.
+   * If this value is not provided, no timeout will be set.
+   * @returns A promise resolving to the result of the task execution.
+   */
+  writeLock(arg0, arg1, arg2) {
+    const [range, task, timeout] = this._handleOverload(
+      [arg0, arg1, arg2],
+      {
+        rangeTask: (range2, task2) => [range2, task2, -1],
+        rangeTaskTimeout: (range2, task2, timeout2) => [range2, task2, timeout2],
+        task: (task2) => [[-Infinity, Infinity], task2, -1],
+        taskTimeout: (task2, timeout2) => [[-Infinity, Infinity], task2, timeout2]
+      },
+      {
+        task: [Function],
+        taskTimeout: [Function, Number],
+        rangeTask: [Array, Function],
+        rangeTaskTimeout: [Array, Function, Number]
+      }
+    );
+    return this._lock(
+      this.writeQueue,
+      range,
+      timeout,
+      task,
+      () => {
+        return !this.rangeOverlapping(this.writings, range) && !this.rangeOverlapping(this.readings, range);
+      }
+    );
+  }
+  /**
+   * Releases a read lock by its lock ID.
+   * @param lockId - The unique identifier for the lock to release.
+   */
+  readUnlock(lockId) {
+    this._free(this.readings, lockId);
+  }
+  /**
+   * Releases a write lock by its lock ID.
+   * @param lockId - The unique identifier for the lock to release.
+   */
+  writeUnlock(lockId) {
+    this._free(this.writings, lockId);
+  }
+};
+var AsyncMVCCTransaction2 = class _AsyncMVCCTransaction2 extends MVCCTransaction2 {
+  lock = new Ryoiki4();
+  async writeLock(fn) {
+    let lockId;
+    return this.lock.writeLock(async (_lockId) => {
+      lockId = _lockId;
+      return fn();
+    }).finally(() => {
+      this.lock.writeUnlock(lockId);
+    });
+  }
+  async create(key, value) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (this.writeBuffer.has(key) || !this.deleteBuffer.has(key) && await this.read(key) !== null) {
+      throw new Error(`Key already exists: ${key}`);
+    }
+    this._bufferCreate(key, value);
+    return this;
+  }
+  async write(key, value) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (!this.writeBuffer.has(key) && (this.deleteBuffer.has(key) || await this.read(key) === null)) {
+      throw new Error(`Key not found: ${key}`);
+    }
+    this._bufferWrite(key, value);
+    return this;
+  }
+  async delete(key) {
+    if (this.committed) throw new Error("Transaction already committed");
+    let valueToDelete = null;
+    let wasInWriteBuffer = false;
+    if (this.writeBuffer.has(key)) {
+      valueToDelete = this.writeBuffer.get(key);
+      wasInWriteBuffer = true;
+    } else if (!this.deleteBuffer.has(key)) {
+      valueToDelete = await this.read(key);
+    }
+    if (valueToDelete === null) {
+      throw new Error(`Key not found: ${key}`);
+    }
+    this.deletedValues.set(key, valueToDelete);
+    if (!wasInWriteBuffer || !this.createdKeys.has(key)) {
+      this.originallyExisted.add(key);
+    }
+    this._bufferDelete(key);
+    return this;
+  }
+  createNested() {
+    if (this.committed) throw new Error("Transaction already committed");
+    const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
+    const child = new _AsyncMVCCTransaction2(void 0, this, childVersion);
+    this.root.activeTransactions.add(child);
+    return child;
+  }
+  async read(key) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
+    if (this.deleteBuffer.has(key)) return null;
+    return this.root._diskRead(key, this.snapshotVersion);
+  }
+  async exists(key) {
+    if (this.committed) throw new Error("Transaction already committed");
+    if (this.deleteBuffer.has(key)) return false;
+    if (this.writeBuffer.has(key)) return true;
+    return this.root._diskExists(key, this.snapshotVersion);
+  }
+  async _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+    if (this.writeBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return this.writeBuffer.get(key);
+      }
+    }
+    if (this.deleteBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return null;
+      }
+    }
+    if (this.parent) {
+      return this.parent._readSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
+    } else {
+      return this._diskRead(key, snapshotVersion);
+    }
+  }
+  async commit(label) {
+    const { created, updated, deleted } = this.getResultEntries();
+    if (this.committed) {
+      return {
+        label,
+        success: false,
+        error: "Transaction already committed",
+        conflict: void 0,
+        created,
+        updated,
+        deleted
+      };
+    }
+    if (this.hasCommittedAncestor()) {
+      return {
+        label,
+        success: false,
+        error: "Ancestor transaction already committed",
+        conflict: void 0,
+        created,
+        updated,
+        deleted
+      };
+    }
+    if (this.parent) {
+      const failure = await this.parent._merge(this);
+      if (failure) {
+        return {
+          label,
+          success: false,
+          error: failure.error,
+          conflict: failure.conflict,
+          created,
+          updated,
+          deleted
+        };
+      }
+      this.committed = true;
+    } else {
+      if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
+        const failure = await this._merge(this);
+        if (failure) {
+          return {
+            label,
+            success: false,
+            error: failure.error,
+            conflict: failure.conflict,
+            created: [],
+            updated: [],
+            deleted: []
+          };
+        }
+        this.writeBuffer.clear();
+        this.deleteBuffer.clear();
+        this.createdKeys.clear();
+        this.deletedValues.clear();
+        this.originallyExisted.clear();
+        this.keyVersions.clear();
+        this.localVersion = 0;
+        this.snapshotVersion = this.version;
+      }
+    }
+    return {
+      label,
+      success: true,
+      created,
+      updated,
+      deleted
+    };
+  }
+  async _merge(child) {
+    return this.writeLock(async () => {
+      if (this.parent) {
+        for (const key of child.writeBuffer.keys()) {
+          const lastModLocalVer = this.keyVersions.get(key);
+          if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
+            return {
+              error: `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`,
+              conflict: {
+                key,
+                parent: await this.read(key),
+                child: await child.read(key)
+              }
+            };
+          }
+        }
+        for (const key of child.deleteBuffer) {
+          const lastModLocalVer = this.keyVersions.get(key);
+          if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
+            return {
+              error: `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`,
+              conflict: {
+                key,
+                parent: await this.read(key),
+                child: await child.read(key)
+              }
+            };
+          }
+        }
+        const newLocalVersion = this.localVersion + 1;
+        for (const key of child.writeBuffer.keys()) {
+          this.writeBuffer.set(key, child.writeBuffer.get(key));
+          this.deleteBuffer.delete(key);
+          this.keyVersions.set(key, newLocalVersion);
+          if (child.createdKeys.has(key)) {
+            this.createdKeys.add(key);
+          }
+        }
+        for (const key of child.deleteBuffer) {
+          this.deleteBuffer.add(key);
+          this.writeBuffer.delete(key);
+          this.createdKeys.delete(key);
+          this.keyVersions.set(key, newLocalVersion);
+          const deletedValue = child.deletedValues.get(key);
+          if (deletedValue !== void 0) {
+            this.deletedValues.set(key, deletedValue);
+          }
+          if (child.originallyExisted.has(key)) {
+            this.originallyExisted.add(key);
+          }
+        }
+        this.localVersion = newLocalVersion;
+        this.root.activeTransactions.delete(child);
+        return null;
+      } else {
+        const newVersion = this.version + 1;
+        if (child !== this) {
+          const modifiedKeys = /* @__PURE__ */ new Set([...child.writeBuffer.keys(), ...child.deleteBuffer]);
+          for (const key of modifiedKeys) {
+            const versions = this.versionIndex.get(key);
+            if (versions && versions.length > 0) {
+              const lastVer = versions[versions.length - 1].version;
+              if (lastVer > child.snapshotVersion) {
+                return {
+                  error: `Commit conflict: Key '${key}' was modified by a newer transaction (v${lastVer})`,
+                  conflict: {
+                    key,
+                    parent: await this.read(key),
+                    child: await child.read(key)
+                  }
+                };
+              }
+            }
+          }
+        }
+        for (const [key, value] of child.writeBuffer) {
+          this.writeBuffer.set(key, value);
+          this.deleteBuffer.delete(key);
+          if (child.createdKeys.has(key)) {
+            this.createdKeys.add(key);
+          }
+        }
+        for (const key of child.deleteBuffer) {
+          this.deleteBuffer.add(key);
+          this.writeBuffer.delete(key);
+          this.createdKeys.delete(key);
+          const deletedValue = child.deletedValues.get(key);
+          if (deletedValue !== void 0) {
+            this.deletedValues.set(key, deletedValue);
+          }
+          if (child.originallyExisted.has(key)) {
+            this.originallyExisted.add(key);
+          }
+        }
+        for (const [key, value] of child.writeBuffer) {
+          await this._diskWrite(key, value, newVersion);
+        }
+        for (const key of child.deleteBuffer) {
+          await this._diskDelete(key, newVersion);
+        }
+        this.version = newVersion;
+        this.root.activeTransactions.delete(child);
+        this._cleanupDeletedCache();
+        return null;
+      }
+    });
+  }
+  // --- Internal IO Helpers (Root Only) ---
+  async _diskWrite(key, value, version) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    if (await strategy.exists(key)) {
+      const currentVal = await strategy.read(key);
+      if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+      this.deletedCache.get(key).push({
+        value: currentVal,
+        deletedAtVersion: version
+      });
+    }
+    await strategy.write(key, value);
+    if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
+    this.versionIndex.get(key).push({ version, exists: true });
+  }
+  async _diskRead(key, snapshotVersion) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    const versions = this.versionIndex.get(key);
+    if (!versions) {
+      return await strategy.exists(key) ? strategy.read(key) : null;
+    }
+    let targetVerObj = null;
+    let nextVerObj = null;
+    for (const v of versions) {
+      if (v.version <= snapshotVersion) {
+        targetVerObj = v;
+      } else {
+        nextVerObj = v;
+        break;
+      }
+    }
+    if (!targetVerObj) {
+      if (nextVerObj) {
+        const cached2 = this.deletedCache.get(key);
+        if (cached2) {
+          const match = cached2.find((c) => c.deletedAtVersion === nextVerObj.version);
+          if (match) return match.value;
+        }
+      }
+      return null;
+    }
+    if (!targetVerObj.exists) return null;
+    if (!nextVerObj) {
+      return strategy.read(key);
+    }
+    const cached = this.deletedCache.get(key);
+    if (cached) {
+      const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
+      if (match) return match.value;
+    }
+    return null;
+  }
+  async _diskExists(key, snapshotVersion) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    const versions = this.versionIndex.get(key);
+    if (!versions) {
+      return strategy.exists(key);
+    }
+    let targetVerObj = null;
+    for (const v of versions) {
+      if (v.version <= snapshotVersion) {
+        targetVerObj = v;
+      } else {
+        break;
+      }
+    }
+    if (!targetVerObj) return strategy.exists(key);
+    return targetVerObj.exists;
+  }
+  async _diskDelete(key, snapshotVersion) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    if (await strategy.exists(key)) {
+      const currentVal = await strategy.read(key);
+      if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+      this.deletedCache.get(key).push({
+        value: currentVal,
+        deletedAtVersion: snapshotVersion
+      });
+    }
+    await strategy.delete(key);
+    if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
+    this.versionIndex.get(key).push({ version: snapshotVersion, exists: false });
+  }
+  _cleanupDeletedCache() {
+    if (this.deletedCache.size === 0) return;
+    let minActiveVersion = this.version;
+    if (this.activeTransactions.size > 0) {
+      for (const tx of this.activeTransactions) {
+        if (!tx.committed && tx.snapshotVersion < minActiveVersion) {
+          minActiveVersion = tx.snapshotVersion;
+        }
+      }
+    }
+    for (const [key, cachedList] of this.deletedCache) {
+      const remaining = cachedList.filter((item) => item.deletedAtVersion > minActiveVersion);
+      if (remaining.length === 0) {
+        this.deletedCache.delete(key);
+      } else {
+        this.deletedCache.set(key, remaining);
+      }
+    }
+  }
+};
+
 // src/utils/numberToBytes.ts
 function numberToBytes(value, buffer, offset = 0, length = buffer.length) {
   if (length === 4) {
@@ -5921,7 +7046,7 @@ var PageManagerFactory = class _PageManagerFactory {
 };
 
 // src/core/DataplyAPI.ts
-var import_node_fs4 = __toESM(require("node:fs"));
+var import_node_fs3 = __toESM(require("node:fs"));
 
 // node_modules/hookall/dist/esm/index.mjs
 var HookallStore = class extends WeakMap {
@@ -6234,12 +7359,9 @@ var HookallSync = class _HookallSync {
   }
 };
 
-// src/core/VirtualFileSystem.ts
-var import_node_fs2 = __toESM(require("node:fs"));
-
-// src/core/LogManager.ts
+// src/core/WALManager.ts
 var import_node_fs = __toESM(require("node:fs"));
-var LogManager = class {
+var WALManager = class {
   fd = null;
   walFilePath;
   pageSize;
@@ -6252,6 +7374,9 @@ var LogManager = class {
    * @param pageSize Page size
    */
   constructor(walFilePath, pageSize) {
+    if ((pageSize & pageSize - 1) !== 0) {
+      throw new Error("Page size must be a power of 2");
+    }
     this.walFilePath = walFilePath;
     this.pageSize = pageSize;
     this.entrySize = 4 + pageSize;
@@ -6264,6 +7389,63 @@ var LogManager = class {
   open() {
     this.fd = import_node_fs.default.openSync(this.walFilePath, "a+");
   }
+  // ─────────────────────────────────────────────────────────────
+  // High-level WAL operations (2-Phase Commit)
+  // ─────────────────────────────────────────────────────────────
+  /**
+   * Performs recovery (Redo) using WAL logs.
+   * Called during initialization, ensuring data is fully restored before operations start.
+   * @param writePage Callback to write recovered pages to disk
+   */
+  async recover(writePage) {
+    this.open();
+    const restoredPages = this.readAllSync();
+    if (restoredPages.size === 0) {
+      return;
+    }
+    const promises = [];
+    for (const [pageId, data] of restoredPages) {
+      if (pageId > 1e6) continue;
+      try {
+        const manager = new PageManagerFactory().getManager(data);
+        if (!manager.verifyChecksum(data)) {
+          console.warn(`[WALManager] 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.`);
+        continue;
+      }
+      promises.push(writePage(pageId, data));
+    }
+    await Promise.all(promises);
+    if (restoredPages.size > 0) {
+      await this.clear();
+    }
+  }
+  /**
+   * WAL에 페이지 데이터를 기록합니다 (Phase 1: Prepare).
+   * @param dirtyPages 변경된 페이지들 (pageId -> data)
+   */
+  async prepareCommit(dirtyPages) {
+    if (dirtyPages.size === 0) {
+      return;
+    }
+    await this.append(dirtyPages);
+  }
+  /**
+   * WAL에 커밋 마커를 기록하고 로그를 정리합니다 (Phase 2: Finalize).
+   * @param hasActiveTransactions 아직 활성 트랜잭션이 있는지 여부
+   */
+  async finalizeCommit(hasActiveTransactions) {
+    await this.writeCommitMarker();
+    if (!hasActiveTransactions) {
+      await this.clear();
+    }
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Low-level WAL operations
+  // ─────────────────────────────────────────────────────────────
   /**
    * Appends changed pages to the log file.
    * Records them sorted by page ID.
@@ -6317,7 +7499,7 @@ var LogManager = class {
   }
   /**
    * Reads the log file to recover the page map.
-   * Runs synchronously as it is called by the VFS constructor.
+   * Runs synchronously as it is called during initialization.
    * Only returns pages from committed transactions (ended with a commit marker).
    * @returns Recovered page map
    */
@@ -6372,173 +7554,15 @@ var LogManager = class {
   }
 };
 
-// src/core/VirtualFileSystem.ts
-var VirtualFileSystem = class {
-  /** Track logical file size */
-  fileSize;
-  /** Page size */
-  pageSize;
-  /** File handle */
-  fileHandle;
-  /** WAL Log Manager */
-  logManager;
-  constructor(fileHandle, pageSize, pageCacheCapacity, walPath) {
-    if ((pageSize & pageSize - 1) !== 0) {
-      throw new Error("Page size must be a power of 2");
-    }
-    this.fileHandle = fileHandle;
-    this.pageSize = pageSize;
-    this.fileSize = import_node_fs2.default.fstatSync(fileHandle).size;
-    if (walPath) {
-      this.logManager = new LogManager(walPath, pageSize);
-    }
-  }
-  /**
-   * Performs recovery (Redo) using WAL logs.
-   * Called during initialization (DataplyAPI.init), ensuring data is fully restored before operations start.
-   */
-  async recover() {
-    if (!this.logManager) return;
-    this.logManager.open();
-    const restoredPages = this.logManager.readAllSync();
-    if (restoredPages.size === 0) {
-      return;
-    }
-    const promises = [];
-    for (const [pageId, data] of restoredPages) {
-      if (pageId > 1e6) continue;
-      try {
-        const manager = new PageManagerFactory().getManager(data);
-        if (!manager.verifyChecksum(data)) {
-          console.warn(`[VFS] Checksum verification failed for PageID ${pageId} during recovery. Ignoring changes.`);
-          continue;
-        }
-      } catch (e) {
-        console.warn(`[VFS] Failed to verify checksum for PageID ${pageId} during recovery: ${e}. Ignoring changes.`);
-        continue;
-      }
-      promises.push(this._writeAsync(
-        this.fileHandle,
-        data,
-        0,
-        this.pageSize,
-        pageId * this.pageSize
-      ));
-      const endPos = (pageId + 1) * this.pageSize;
-      if (endPos > this.fileSize) {
-        this.fileSize = endPos;
-      }
-    }
-    await Promise.all(promises);
-    if (this.logManager && restoredPages.size > 0) {
-      await this.logManager.clear();
-    }
-  }
-  /**
-   * WAL에 페이지 데이터를 기록합니다 (Phase 1).
-   * @param dirtyPages 변경된 페이지들 (pageId -> data)
-   */
-  async prepareCommitWAL(dirtyPages) {
-    if (!this.logManager || dirtyPages.size === 0) {
-      return;
-    }
-    await this.logManager.append(dirtyPages);
-  }
-  /**
-   * WAL에 커밋 마커를 기록하고 로그를 정리합니다 (Phase 2).
-   * @param hasActiveTransactions 아직 활성 트랜잭션이 있는지 여부
-   */
-  async finalizeCommitWAL(hasActiveTransactions) {
-    if (!this.logManager) {
-      return;
-    }
-    await this.logManager.writeCommitMarker();
-    if (!hasActiveTransactions) {
-      await this.logManager.clear();
-    }
-  }
-  /**
-   * 디스크에서 페이지를 읽습니다.
-   * @param pageId Page ID
-   * @returns Page data
-   */
-  async readPage(pageId) {
-    const buffer = new Uint8Array(this.pageSize);
-    const pageStartPos = pageId * this.pageSize;
-    if (pageStartPos >= this.fileSize) {
-      return buffer;
-    }
-    await this._readAsync(this.fileHandle, buffer, 0, this.pageSize, pageStartPos);
-    return buffer;
-  }
-  /**
-   * 디스크에 페이지를 씁니다.
-   * @param pageId Page ID
-   * @param data Page data
-   */
-  async writePage(pageId, data) {
-    const pageStartPos = pageId * this.pageSize;
-    if (pageStartPos + this.pageSize > 512 * 1024 * 1024) {
-      throw new Error(`[Safety Limit] File write exceeds 512MB limit at position ${pageStartPos}`);
-    }
-    await this._writeAsync(this.fileHandle, data, 0, this.pageSize, pageStartPos);
-    const endPosition = pageStartPos + this.pageSize;
-    if (endPosition > this.fileSize) {
-      this.fileSize = endPosition;
-    }
-  }
-  /**
-   * 현재 파일 크기 반환
-   */
-  getFileSize() {
-    return this.fileSize;
-  }
-  /**
-   * Closes the file.
-   */
-  async close() {
-    if (this.logManager) {
-      this.logManager.close();
-    }
-  }
-  _readAsync(handle, buffer, offset, length, position) {
-    return new Promise((resolve, reject) => {
-      import_node_fs2.default.read(handle, buffer, offset, length, position, (err, bytesRead) => {
-        if (err) return reject(err);
-        resolve(bytesRead);
-      });
-    });
-  }
-  _writeAsync(handle, buffer, offset, length, 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) => {
-        if (err) return reject(err);
-        resolve(bytesWritten);
-      });
-    });
-  }
-};
-
-// src/core/PageMVCCStrategy.ts
-var import_node_fs3 = __toESM(require("node:fs"));
-
-// node_modules/mvcc-api/dist/esm/index.mjs
-var MVCCStrategy2 = class {
-};
-var AsyncMVCCStrategy2 = class extends MVCCStrategy2 {
-};
-
 // src/core/PageMVCCStrategy.ts
+var import_node_fs2 = __toESM(require("node:fs"));
 var PageMVCCStrategy = class extends AsyncMVCCStrategy2 {
   constructor(fileHandle, pageSize, cacheCapacity) {
     super();
     this.fileHandle = fileHandle;
     this.pageSize = pageSize;
     this.cache = new LRUMap2(cacheCapacity);
-    this.fileSize = import_node_fs3.default.fstatSync(fileHandle).size;
+    this.fileSize = import_node_fs2.default.fstatSync(fileHandle).size;
   }
   /** LRU 캐시 (페이지 ID -> 페이지 데이터) */
   cache;
@@ -6621,7 +7645,7 @@ var PageMVCCStrategy = class extends AsyncMVCCStrategy2 {
   // ─────────────────────────────────────────────────────────────
   _readFromDisk(buffer, position) {
     return new Promise((resolve, reject) => {
-      import_node_fs3.default.read(this.fileHandle, buffer, 0, this.pageSize, position, (err, bytesRead) => {
+      import_node_fs2.default.read(this.fileHandle, buffer, 0, this.pageSize, position, (err, bytesRead) => {
         if (err) return reject(err);
         resolve(bytesRead);
       });
@@ -6629,7 +7653,7 @@ var PageMVCCStrategy = class extends AsyncMVCCStrategy2 {
   }
   _writeToDisk(buffer, position) {
     return new Promise((resolve, reject) => {
-      import_node_fs3.default.write(this.fileHandle, buffer, 0, this.pageSize, position, (err, bytesWritten) => {
+      import_node_fs2.default.write(this.fileHandle, buffer, 0, this.pageSize, position, (err, bytesWritten) => {
         if (err) return reject(err);
         resolve(bytesWritten);
       });
@@ -6650,20 +7674,24 @@ var PageFileSystem = class {
     this.pageSize = pageSize;
     this.pageCacheCapacity = pageCacheCapacity;
     this.walPath = walPath;
-    this.vfs = new VirtualFileSystem(fileHandle, pageSize, pageCacheCapacity, walPath);
+    this.walManager = walPath ? new WALManager(walPath, pageSize) : null;
     this.pageManagerFactory = new PageManagerFactory();
     this.pageStrategy = new PageMVCCStrategy(fileHandle, pageSize, pageCacheCapacity);
   }
   pageFactory = new PageManagerFactory();
-  vfs;
+  walManager;
   pageManagerFactory;
   pageStrategy;
   /**
    * Initializes the page file system.
-   * Performs VFS recovery if necessary.
+   * Performs WAL recovery if necessary.
    */
   async init() {
-    await this.vfs.recover();
+    if (this.walManager) {
+      await this.walManager.recover(async (pageId, data) => {
+        await this.pageStrategy.write(pageId, data);
+      });
+    }
   }
   /**
    * Returns the page strategy for transaction use.
@@ -6709,10 +7737,10 @@ var PageFileSystem = class {
     await this.setPage(currentBitmapPageId, targetBitmapPage, tx);
   }
   /**
-   * VFS 인스턴스를 반환합니다.
+   * WAL Manager 인스턴스를 반환합니다.
    */
-  get vfsInstance() {
-    return this.vfs;
+  get wal() {
+    return this.walManager;
   }
   /**
    * 페이지 Strategy를 반환합니다.
@@ -6947,14 +7975,18 @@ var PageFileSystem = class {
    * @param dirtyPages 변경된 페이지들
    */
   async commitToWAL(dirtyPages) {
-    await this.vfs.prepareCommitWAL(dirtyPages);
-    await this.vfs.finalizeCommitWAL(false);
+    if (this.walManager) {
+      await this.walManager.prepareCommit(dirtyPages);
+      await this.walManager.finalizeCommit(false);
+    }
   }
   /**
    * Closes the page file system.
    */
   async close() {
-    await this.vfs.close();
+    if (this.walManager) {
+      this.walManager.close();
+    }
   }
 };
 
@@ -7835,7 +8867,7 @@ var DataplyAPI = class {
     this.file = file;
     this.hook = useHookall(this);
     this.options = this.verboseOptions(options);
-    this.isNewlyCreated = !import_node_fs4.default.existsSync(file);
+    this.isNewlyCreated = !import_node_fs3.default.existsSync(file);
     this.fileHandle = this.createOrOpen(file, this.options);
     this.pfs = new PageFileSystem(
       this.fileHandle,
@@ -7884,7 +8916,7 @@ var DataplyAPI = class {
   verifyFormat(fileHandle) {
     const size = MetadataPageManager.CONSTANT.OFFSET_MAGIC_STRING + MetadataPageManager.CONSTANT.MAGIC_STRING.length;
     const metadataPage = new Uint8Array(size);
-    import_node_fs4.default.readSync(fileHandle, metadataPage, 0, size, 0);
+    import_node_fs3.default.readSync(fileHandle, metadataPage, 0, size, 0);
     if (!MetadataPageManager.IsMetadataPage(metadataPage)) {
       return false;
     }
@@ -7946,7 +8978,7 @@ var DataplyAPI = class {
       -1,
       options.pageSize - DataPageManager.CONSTANT.SIZE_PAGE_HEADER
     );
-    import_node_fs4.default.appendFileSync(fileHandle, new Uint8Array([
+    import_node_fs3.default.appendFileSync(fileHandle, new Uint8Array([
       ...metadataPage,
       ...bitmapPage,
       ...dataPage
@@ -7963,18 +8995,18 @@ var DataplyAPI = class {
     if (options.pageCacheCapacity < 100) {
       throw new Error("Page cache capacity must be at least 100");
     }
-    if (!import_node_fs4.default.existsSync(file)) {
+    if (!import_node_fs3.default.existsSync(file)) {
       if (options.pageSize < 4096) {
         throw new Error("Page size must be at least 4096 bytes");
       }
-      fileHandle = import_node_fs4.default.openSync(file, "w+");
+      fileHandle = import_node_fs3.default.openSync(file, "w+");
       this.initializeFile(file, fileHandle, options);
     } else {
-      fileHandle = import_node_fs4.default.openSync(file, "r+");
+      fileHandle = import_node_fs3.default.openSync(file, "r+");
       const buffer = new Uint8Array(
         MetadataPageManager.CONSTANT.OFFSET_PAGE_SIZE + MetadataPageManager.CONSTANT.SIZE_PAGE_SIZE
       );
-      import_node_fs4.default.readSync(fileHandle, buffer);
+      import_node_fs3.default.readSync(fileHandle, buffer);
       const metadataManager = new MetadataPageManager();
       if (metadataManager.isMetadataPage(buffer)) {
         const storedPageSize = metadataManager.getPageSize(buffer);
@@ -8169,7 +9201,7 @@ var DataplyAPI = class {
     }
     return this.hook.trigger("close", void 0, async () => {
       await this.pfs.close();
-      import_node_fs4.default.closeSync(this.fileHandle);
+      import_node_fs3.default.closeSync(this.fileHandle);
     });
   }
 };
@@ -8301,6 +9333,8 @@ var GlobalTransaction = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AsyncMVCCStrategy,
+  AsyncMVCCTransaction,
   BPTreeAsync,
   BPTreeAsyncTransaction,
   BPTreeSync,
@@ -8318,6 +9352,8 @@ var GlobalTransaction = class {
   IndexPageManager,
   InvertedWeakMap,
   LRUMap,
+  MVCCStrategy,
+  MVCCTransaction,
   MetadataPageManager,
   NumericComparator,
   OverflowPageManager,
@@ -8327,6 +9363,8 @@ var GlobalTransaction = class {
   SerializeStrategyAsync,
   SerializeStrategySync,
   StringComparator,
+  SyncMVCCStrategy,
+  SyncMVCCTransaction,
   Transaction,
   UnknownPageManager,
   ValueComparator