mvcc-api 1.2.11 → 1.3.0

package/dist/cjs/index.cjs

@@ -196,7 +196,9 @@ var MVCCTransaction = class {
             break;
           }
         }
-        if (latestInSnapshotIdx > 0) {
+        if (latestInSnapshotIdx === versions.length - 1) {
+          this.versionIndex.delete(key);
+        } else if (latestInSnapshotIdx > 0) {
           versions.splice(0, latestInSnapshotIdx);
         }
       }
@@ -265,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);
@@ -407,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) {
@@ -426,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;
   }
@@ -479,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;
@@ -499,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);
@@ -517,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;
@@ -540,8 +600,8 @@ 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 });
   }
@@ -876,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);
@@ -1020,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) {
@@ -1039,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;
       }
     });
@@ -1093,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;
@@ -1113,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);
@@ -1131,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;
@@ -1154,8 +1272,8 @@ 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 });
   }

package/dist/esm/index.mjs

@@ -165,7 +165,9 @@ var MVCCTransaction = class {
             break;
           }
         }
-        if (latestInSnapshotIdx > 0) {
+        if (latestInSnapshotIdx === versions.length - 1) {
+          this.versionIndex.delete(key);
+        } else if (latestInSnapshotIdx > 0) {
           versions.splice(0, latestInSnapshotIdx);
         }
       }
@@ -234,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);
@@ -376,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) {
@@ -395,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;
   }
@@ -448,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;
@@ -468,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);
@@ -486,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;
@@ -509,8 +569,8 @@ 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 });
   }
@@ -845,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);
@@ -989,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) {
@@ -1008,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;
       }
     });
@@ -1062,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;
@@ -1082,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);
@@ -1100,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;
@@ -1123,8 +1241,8 @@ 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 });
   }

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>;

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

@@ -120,6 +120,14 @@ 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.

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;

package/package.json

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