mvcc-api 1.2.10 → 1.3.0

package/dist/cjs/index.cjs

@@ -163,6 +163,47 @@ var MVCCTransaction = class {
     }
     return { success: true, created, updated, deleted };
   }
+  /**
+   * Cleans up both deletedCache and versionIndex based on minActiveVersion.
+   * Root transactions call this after commit to reclaim memory.
+   */
+  _cleanupDeletedCache() {
+    if (this.deletedCache.size === 0 && this.versionIndex.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;
+        }
+      }
+    }
+    if (this.deletedCache.size > 0) {
+      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);
+        }
+      }
+    }
+    if (this.versionIndex.size > 0) {
+      for (const [key, versions] of this.versionIndex) {
+        let latestInSnapshotIdx = -1;
+        for (let i = versions.length - 1; i >= 0; i--) {
+          if (versions[i].version <= minActiveVersion) {
+            latestInSnapshotIdx = i;
+            break;
+          }
+        }
+        if (latestInSnapshotIdx === versions.length - 1) {
+          this.versionIndex.delete(key);
+        } else if (latestInSnapshotIdx > 0) {
+          versions.splice(0, latestInSnapshotIdx);
+        }
+      }
+    }
+  }
 };
 
 // src/core/sync/Strategy.ts
@@ -226,6 +267,25 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (this.writeBuffer.has(key)) return true;
     return this.root._diskExists(key, this.snapshotVersion);
   }
+  _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+    if (this.writeBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return true;
+      }
+    }
+    if (this.deleteBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return false;
+      }
+    }
+    if (this.parent) {
+      return this.parent._existsSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
+    } else {
+      return this._diskExists(key, snapshotVersion);
+    }
+  }
   _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
     if (this.writeBuffer.has(key)) {
       const keyModVersion = this.keyVersions.get(key);
@@ -368,7 +428,6 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
       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) {
@@ -387,35 +446,70 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
             }
           }
         }
-      }
-      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);
+        const newVersion = this.version + 1;
+        for (const [key, value] of child.writeBuffer) {
+          if (this.writeBuffer.has(key)) {
+            if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+            this.deletedCache.get(key).push({
+              value: this.writeBuffer.get(key),
+              deletedAtVersion: newVersion
+            });
+          } else if (this.strategy.exists(key)) {
+            if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+            this.deletedCache.get(key).push({
+              value: this.strategy.read(key),
+              deletedAtVersion: newVersion
+            });
+          }
+          this.writeBuffer.set(key, value);
+          this.deleteBuffer.delete(key);
+          if (child.createdKeys.has(key)) {
+            this.createdKeys.add(key);
+          }
+          if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
+          this.versionIndex.get(key).push({ version: newVersion, exists: true });
         }
-      }
-      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);
+        for (const key of child.deleteBuffer) {
+          if (this.writeBuffer.has(key)) {
+            if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+            this.deletedCache.get(key).push({
+              value: this.writeBuffer.get(key),
+              deletedAtVersion: newVersion
+            });
+          } else if (this.strategy.exists(key)) {
+            if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+            this.deletedCache.get(key).push({
+              value: this.strategy.read(key),
+              deletedAtVersion: newVersion
+            });
+          }
+          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);
+          }
+          if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
+          this.versionIndex.get(key).push({ version: newVersion, exists: false });
         }
-        if (child.originallyExisted.has(key)) {
-          this.originallyExisted.add(key);
+        this.version = newVersion;
+        this.root.activeTransactions.delete(child);
+        this._cleanupDeletedCache();
+      } else {
+        const newVersion = this.version + 1;
+        for (const [key, value] of this.writeBuffer) {
+          this._diskWrite(key, value, newVersion);
         }
+        for (const key of this.deleteBuffer) {
+          this._diskDelete(key, newVersion);
+        }
+        this.version = newVersion;
+        this._cleanupDeletedCache();
       }
-      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;
   }
@@ -440,6 +534,8 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
+      if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
+      if (this.deleteBuffer.has(key)) return null;
       return strategy.exists(key) ? strategy.read(key) : null;
     }
     let targetVerObj = null;
@@ -460,10 +556,11 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
           if (match) return match.value;
         }
       }
-      return null;
+      return strategy.exists(key) ? strategy.read(key) : null;
     }
     if (!targetVerObj.exists) return null;
     if (!nextVerObj) {
+      if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
       return strategy.read(key);
     }
     const cached = this.deletedCache.get(key);
@@ -478,6 +575,8 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
+      if (this.writeBuffer.has(key)) return true;
+      if (this.deleteBuffer.has(key)) return false;
       return strategy.exists(key);
     }
     let targetVerObj = null;
@@ -501,30 +600,11 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
         value: currentVal,
         deletedAtVersion: snapshotVersion
       });
+      strategy.delete(key);
     }
-    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/core/async/Strategy.ts
@@ -856,6 +936,25 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (this.writeBuffer.has(key)) return true;
     return this.root._diskExists(key, this.snapshotVersion);
   }
+  async _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+    if (this.writeBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return true;
+      }
+    }
+    if (this.deleteBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return false;
+      }
+    }
+    if (this.parent) {
+      return this.parent._existsSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
+    } else {
+      return this._diskExists(key, snapshotVersion);
+    }
+  }
   async _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
     if (this.writeBuffer.has(key)) {
       const keyModVersion = this.keyVersions.get(key);
@@ -1000,7 +1099,6 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
         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) {
@@ -1019,35 +1117,70 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
               }
             }
           }
-        }
-        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);
+          const newVersion = this.version + 1;
+          for (const [key, value] of child.writeBuffer) {
+            if (this.writeBuffer.has(key)) {
+              if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+              this.deletedCache.get(key).push({
+                value: this.writeBuffer.get(key),
+                deletedAtVersion: newVersion
+              });
+            } else if (await this.strategy.exists(key)) {
+              if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+              this.deletedCache.get(key).push({
+                value: await this.strategy.read(key),
+                deletedAtVersion: newVersion
+              });
+            }
+            this.writeBuffer.set(key, value);
+            this.deleteBuffer.delete(key);
+            if (child.createdKeys.has(key)) {
+              this.createdKeys.add(key);
+            }
+            if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
+            this.versionIndex.get(key).push({ version: newVersion, exists: true });
           }
-        }
-        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);
+          for (const key of child.deleteBuffer) {
+            if (this.writeBuffer.has(key)) {
+              if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+              this.deletedCache.get(key).push({
+                value: this.writeBuffer.get(key),
+                deletedAtVersion: newVersion
+              });
+            } else if (await this.strategy.exists(key)) {
+              if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+              this.deletedCache.get(key).push({
+                value: await this.strategy.read(key),
+                deletedAtVersion: newVersion
+              });
+            }
+            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);
+            }
+            if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
+            this.versionIndex.get(key).push({ version: newVersion, exists: false });
           }
-          if (child.originallyExisted.has(key)) {
-            this.originallyExisted.add(key);
+          this.version = newVersion;
+          this.root.activeTransactions.delete(child);
+          this._cleanupDeletedCache();
+        } else {
+          const newVersion = this.version + 1;
+          for (const [key, value] of this.writeBuffer) {
+            await this._diskWrite(key, value, newVersion);
           }
+          for (const key of this.deleteBuffer) {
+            await this._diskDelete(key, newVersion);
+          }
+          this.version = newVersion;
+          this._cleanupDeletedCache();
         }
-        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;
       }
     });
@@ -1073,6 +1206,8 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
+      if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
+      if (this.deleteBuffer.has(key)) return null;
       return await strategy.exists(key) ? strategy.read(key) : null;
     }
     let targetVerObj = null;
@@ -1093,10 +1228,11 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
           if (match) return match.value;
         }
       }
-      return null;
+      return await strategy.exists(key) ? strategy.read(key) : null;
     }
     if (!targetVerObj.exists) return null;
     if (!nextVerObj) {
+      if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
       return strategy.read(key);
     }
     const cached = this.deletedCache.get(key);
@@ -1111,6 +1247,8 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
+      if (this.writeBuffer.has(key)) return true;
+      if (this.deleteBuffer.has(key)) return false;
       return strategy.exists(key);
     }
     let targetVerObj = null;
@@ -1134,28 +1272,9 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
         value: currentVal,
         deletedAtVersion: snapshotVersion
       });
+      await strategy.delete(key);
     }
-    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);
-      }
-    }
-  }
 };

package/dist/esm/index.mjs

@@ -132,6 +132,47 @@ var MVCCTransaction = class {
     }
     return { success: true, created, updated, deleted };
   }
+  /**
+   * Cleans up both deletedCache and versionIndex based on minActiveVersion.
+   * Root transactions call this after commit to reclaim memory.
+   */
+  _cleanupDeletedCache() {
+    if (this.deletedCache.size === 0 && this.versionIndex.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;
+        }
+      }
+    }
+    if (this.deletedCache.size > 0) {
+      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);
+        }
+      }
+    }
+    if (this.versionIndex.size > 0) {
+      for (const [key, versions] of this.versionIndex) {
+        let latestInSnapshotIdx = -1;
+        for (let i = versions.length - 1; i >= 0; i--) {
+          if (versions[i].version <= minActiveVersion) {
+            latestInSnapshotIdx = i;
+            break;
+          }
+        }
+        if (latestInSnapshotIdx === versions.length - 1) {
+          this.versionIndex.delete(key);
+        } else if (latestInSnapshotIdx > 0) {
+          versions.splice(0, latestInSnapshotIdx);
+        }
+      }
+    }
+  }
 };
 
 // src/core/sync/Strategy.ts
@@ -195,6 +236,25 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (this.writeBuffer.has(key)) return true;
     return this.root._diskExists(key, this.snapshotVersion);
   }
+  _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+    if (this.writeBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return true;
+      }
+    }
+    if (this.deleteBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return false;
+      }
+    }
+    if (this.parent) {
+      return this.parent._existsSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
+    } else {
+      return this._diskExists(key, snapshotVersion);
+    }
+  }
   _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
     if (this.writeBuffer.has(key)) {
       const keyModVersion = this.keyVersions.get(key);
@@ -337,7 +397,6 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
       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) {
@@ -356,35 +415,70 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
             }
           }
         }
-      }
-      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);
+        const newVersion = this.version + 1;
+        for (const [key, value] of child.writeBuffer) {
+          if (this.writeBuffer.has(key)) {
+            if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+            this.deletedCache.get(key).push({
+              value: this.writeBuffer.get(key),
+              deletedAtVersion: newVersion
+            });
+          } else if (this.strategy.exists(key)) {
+            if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+            this.deletedCache.get(key).push({
+              value: this.strategy.read(key),
+              deletedAtVersion: newVersion
+            });
+          }
+          this.writeBuffer.set(key, value);
+          this.deleteBuffer.delete(key);
+          if (child.createdKeys.has(key)) {
+            this.createdKeys.add(key);
+          }
+          if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
+          this.versionIndex.get(key).push({ version: newVersion, exists: true });
         }
-      }
-      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);
+        for (const key of child.deleteBuffer) {
+          if (this.writeBuffer.has(key)) {
+            if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+            this.deletedCache.get(key).push({
+              value: this.writeBuffer.get(key),
+              deletedAtVersion: newVersion
+            });
+          } else if (this.strategy.exists(key)) {
+            if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+            this.deletedCache.get(key).push({
+              value: this.strategy.read(key),
+              deletedAtVersion: newVersion
+            });
+          }
+          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);
+          }
+          if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
+          this.versionIndex.get(key).push({ version: newVersion, exists: false });
         }
-        if (child.originallyExisted.has(key)) {
-          this.originallyExisted.add(key);
+        this.version = newVersion;
+        this.root.activeTransactions.delete(child);
+        this._cleanupDeletedCache();
+      } else {
+        const newVersion = this.version + 1;
+        for (const [key, value] of this.writeBuffer) {
+          this._diskWrite(key, value, newVersion);
         }
+        for (const key of this.deleteBuffer) {
+          this._diskDelete(key, newVersion);
+        }
+        this.version = newVersion;
+        this._cleanupDeletedCache();
       }
-      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;
   }
@@ -409,6 +503,8 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
+      if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
+      if (this.deleteBuffer.has(key)) return null;
       return strategy.exists(key) ? strategy.read(key) : null;
     }
     let targetVerObj = null;
@@ -429,10 +525,11 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
           if (match) return match.value;
         }
       }
-      return null;
+      return strategy.exists(key) ? strategy.read(key) : null;
     }
     if (!targetVerObj.exists) return null;
     if (!nextVerObj) {
+      if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
       return strategy.read(key);
     }
     const cached = this.deletedCache.get(key);
@@ -447,6 +544,8 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
+      if (this.writeBuffer.has(key)) return true;
+      if (this.deleteBuffer.has(key)) return false;
       return strategy.exists(key);
     }
     let targetVerObj = null;
@@ -470,30 +569,11 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
         value: currentVal,
         deletedAtVersion: snapshotVersion
       });
+      strategy.delete(key);
     }
-    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/core/async/Strategy.ts
@@ -825,6 +905,25 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (this.writeBuffer.has(key)) return true;
     return this.root._diskExists(key, this.snapshotVersion);
   }
+  async _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+    if (this.writeBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return true;
+      }
+    }
+    if (this.deleteBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return false;
+      }
+    }
+    if (this.parent) {
+      return this.parent._existsSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
+    } else {
+      return this._diskExists(key, snapshotVersion);
+    }
+  }
   async _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
     if (this.writeBuffer.has(key)) {
       const keyModVersion = this.keyVersions.get(key);
@@ -969,7 +1068,6 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
         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) {
@@ -988,35 +1086,70 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
               }
             }
           }
-        }
-        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);
+          const newVersion = this.version + 1;
+          for (const [key, value] of child.writeBuffer) {
+            if (this.writeBuffer.has(key)) {
+              if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+              this.deletedCache.get(key).push({
+                value: this.writeBuffer.get(key),
+                deletedAtVersion: newVersion
+              });
+            } else if (await this.strategy.exists(key)) {
+              if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+              this.deletedCache.get(key).push({
+                value: await this.strategy.read(key),
+                deletedAtVersion: newVersion
+              });
+            }
+            this.writeBuffer.set(key, value);
+            this.deleteBuffer.delete(key);
+            if (child.createdKeys.has(key)) {
+              this.createdKeys.add(key);
+            }
+            if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
+            this.versionIndex.get(key).push({ version: newVersion, exists: true });
           }
-        }
-        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);
+          for (const key of child.deleteBuffer) {
+            if (this.writeBuffer.has(key)) {
+              if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+              this.deletedCache.get(key).push({
+                value: this.writeBuffer.get(key),
+                deletedAtVersion: newVersion
+              });
+            } else if (await this.strategy.exists(key)) {
+              if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+              this.deletedCache.get(key).push({
+                value: await this.strategy.read(key),
+                deletedAtVersion: newVersion
+              });
+            }
+            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);
+            }
+            if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
+            this.versionIndex.get(key).push({ version: newVersion, exists: false });
           }
-          if (child.originallyExisted.has(key)) {
-            this.originallyExisted.add(key);
+          this.version = newVersion;
+          this.root.activeTransactions.delete(child);
+          this._cleanupDeletedCache();
+        } else {
+          const newVersion = this.version + 1;
+          for (const [key, value] of this.writeBuffer) {
+            await this._diskWrite(key, value, newVersion);
           }
+          for (const key of this.deleteBuffer) {
+            await this._diskDelete(key, newVersion);
+          }
+          this.version = newVersion;
+          this._cleanupDeletedCache();
         }
-        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;
       }
     });
@@ -1042,6 +1175,8 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
+      if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
+      if (this.deleteBuffer.has(key)) return null;
       return await strategy.exists(key) ? strategy.read(key) : null;
     }
     let targetVerObj = null;
@@ -1062,10 +1197,11 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
           if (match) return match.value;
         }
       }
-      return null;
+      return await strategy.exists(key) ? strategy.read(key) : null;
     }
     if (!targetVerObj.exists) return null;
     if (!nextVerObj) {
+      if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
       return strategy.read(key);
     }
     const cached = this.deletedCache.get(key);
@@ -1080,6 +1216,8 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
+      if (this.writeBuffer.has(key)) return true;
+      if (this.deleteBuffer.has(key)) return false;
       return strategy.exists(key);
     }
     let targetVerObj = null;
@@ -1103,30 +1241,11 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
         value: currentVal,
         deletedAtVersion: snapshotVersion
       });
+      await strategy.delete(key);
     }
-    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);
-      }
-    }
-  }
 };
 export {
   AsyncMVCCStrategy,

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

@@ -10,6 +10,7 @@ export declare class AsyncMVCCTransaction<S extends AsyncMVCCStrategy<K, T>, K,
     createNested(): this;
     read(key: K): Promise<T | null>;
     exists(key: K): Promise<boolean>;
+    _existsSnapshot(key: K, snapshotVersion: number, snapshotLocalVersion?: number): Promise<boolean>;
     _readSnapshot(key: K, snapshotVersion: number, snapshotLocalVersion?: number): Promise<T | null>;
     commit(label?: string): Promise<TransactionResult<K, T>>;
     _merge(child: AsyncMVCCTransaction<S, K, T>): Promise<TransactionMergeFailure<K, T> | null>;
@@ -17,5 +18,4 @@ export declare class AsyncMVCCTransaction<S extends AsyncMVCCStrategy<K, T>, K,
     _diskRead(key: K, snapshotVersion: number): Promise<T | null>;
     _diskExists(key: K, snapshotVersion: number): Promise<boolean>;
     _diskDelete(key: K, snapshotVersion: number): Promise<void>;
-    _cleanupDeletedCache(): void;
 }

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

@@ -120,4 +120,17 @@ export declare abstract class MVCCTransaction<S extends MVCCStrategy<K, T>, K, T
      * @param snapshotLocalVersion The local version within the parent's buffer to read at.
      */
     abstract _readSnapshot(key: K, snapshotVersion: number, snapshotLocalVersion?: number): Deferred<T | null>;
+    /**
+     * Checks if a key exists at a specific snapshot version.
+     * Used by child transactions to check existence from parent respecting the child's snapshot.
+     * @param key The key to check.
+     * @param snapshotVersion The global version to check at.
+     * @param snapshotLocalVersion The local version within the parent's buffer to check at.
+     */
+    abstract _existsSnapshot(key: K, snapshotVersion: number, snapshotLocalVersion?: number): Deferred<boolean>;
+    /**
+     * Cleans up both deletedCache and versionIndex based on minActiveVersion.
+     * Root transactions call this after commit to reclaim memory.
+     */
+    protected _cleanupDeletedCache(): void;
 }

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

@@ -8,6 +8,7 @@ export declare class SyncMVCCTransaction<S extends SyncMVCCStrategy<K, T>, K, T>
     createNested(): this;
     read(key: K): T | null;
     exists(key: K): boolean;
+    _existsSnapshot(key: K, snapshotVersion: number, snapshotLocalVersion?: number): boolean;
     _readSnapshot(key: K, snapshotVersion: number, snapshotLocalVersion?: number): T | null;
     commit(label?: string): TransactionResult<K, T>;
     _merge(child: SyncMVCCTransaction<S, K, T>): TransactionMergeFailure<K, T> | null;
@@ -15,5 +16,4 @@ export declare class SyncMVCCTransaction<S extends SyncMVCCStrategy<K, T>, K, T>
     _diskRead(key: K, snapshotVersion: number): T | null;
     _diskExists(key: K, snapshotVersion: number): boolean;
     _diskDelete(key: K, snapshotVersion: number): void;
-    _cleanupDeletedCache(): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mvcc-api",
-  "version": "1.2.10",
+  "version": "1.3.0",
   "description": "Multiversion Concurrency Control (MVCC) API for TypeScript",
   "license": "MIT",
   "author": "izure <admin@izure.org>",