react-native-nitro-storage 0.7.0 → 0.9.0

package/lib/commonjs/storage-core.js

@@ -4,10 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createStorageCore = createStorageCore;
-var _shared = require("./shared");
-var _Storage = require("./Storage.types");
+var _durability = require("./core/durability");
+var _metrics = require("./core/metrics");
 var _internal = require("./internal");
+var _shared = require("./shared");
 var _storageEvents = require("./storage-events");
+var _Storage = require("./Storage.types");
 const EMPTY_KEYS = Object.freeze([]);
 function asInternal(item) {
   return item;
@@ -18,55 +20,38 @@ function createStorageCore(buildAdapter) {
   const registeredKeyCounts = new Map();
   const memoryStore = new Map();
   const memoryListeners = new Map();
-  const scopedListeners = new Map([[_Storage.StorageScope.Disk, new Map()], [_Storage.StorageScope.Secure, new Map()]]);
-  const scopedRawCache = new Map([[_Storage.StorageScope.Disk, new Map()], [_Storage.StorageScope.Secure, new Map()]]);
-  const pendingDiskWrites = new Map();
-  let diskFlushScheduled = false;
-  let diskWritesAsync = false;
-  const pendingSecureWrites = new Map();
-  let secureFlushScheduled = false;
+  const scopedListeners = {
+    [_Storage.StorageScope.Disk]: new Map(),
+    [_Storage.StorageScope.Secure]: new Map()
+  };
+  const scopedRawCache = {
+    [_Storage.StorageScope.Disk]: new Map(),
+    [_Storage.StorageScope.Secure]: new Map()
+  };
   let secureDefaultAccessControl = _Storage.AccessControl.WhenUnlocked;
-  let metricsObserver;
   let eventObserver;
   let eventObserverRedactSecureValues = true;
-  const metricsCounters = new Map();
   const storageEvents = new _storageEvents.StorageEventRegistry();
-  function recordMetric(operation, scope, durationMs, keysCount = 1) {
-    const existing = metricsCounters.get(operation);
-    if (!existing) {
-      metricsCounters.set(operation, {
-        count: 1,
-        totalDurationMs: durationMs,
-        maxDurationMs: durationMs
-      });
-    } else {
-      existing.count += 1;
-      existing.totalDurationMs += durationMs;
-      existing.maxDurationMs = Math.max(existing.maxDurationMs, durationMs);
-    }
-    metricsObserver?.({
-      operation,
-      scope,
-      durationMs,
-      keysCount
-    });
-  }
-  function measureOperation(operation, scope, fn, keysCount = 1) {
-    if (!metricsObserver) {
-      return fn();
-    }
-    const start = (0, _shared.now)();
-    try {
-      return fn();
-    } finally {
-      recordMetric(operation, scope, (0, _shared.now)() - start, keysCount);
-    }
-  }
+  const metrics = (0, _metrics.createMetricsRegistry)();
+  const durability = (0, _durability.createDurabilityCoordinator)({
+    backend: {
+      setBatch: (keys, values, scope) => {
+        adapter.backend.setBatch(keys, values, scope);
+      },
+      removeBatch: (keys, scope) => {
+        adapter.backend.removeBatch(keys, scope);
+      },
+      setSecureAccessControl: level => {
+        adapter.backend.setSecureAccessControl(level);
+      }
+    },
+    resolveSecureDefaultAccessControl: () => secureDefaultAccessControl
+  });
   function getScopedListeners(scope) {
-    return scopedListeners.get(scope);
+    return scopedListeners[scope];
   }
   function getScopeRawCache(scope) {
-    return scopedRawCache.get(scope);
+    return scopedRawCache[scope];
   }
   function cacheRawValue(scope, key, value) {
     getScopeRawCache(scope).set(key, value);
@@ -98,7 +83,7 @@ function createStorageCore(buildAdapter) {
   function getEventRawValue(scope, key) {
     if (scope === _Storage.StorageScope.Memory) {
       const value = memoryStore.get(key);
-      return typeof value === "string" ? value : undefined;
+      return typeof value === "string" ? (0, _internal.unescapeCollidingRawValue)(value) : undefined;
     }
     return getRawValue(key, scope);
   }
@@ -144,118 +129,49 @@ function createStorageCore(buildAdapter) {
     storageEvents.emitBatch(event);
     eventObserver?.(eventForGlobalObserver(event));
   }
+  function measureOperation(operation, scope, fn, keysCount = 1) {
+    return metrics.measure(operation, scope, fn, keysCount);
+  }
+  function recordMetric(operation, scope, durationMs, keysCount = 1) {
+    metrics.record(operation, scope, durationMs, keysCount);
+  }
   function readPendingSecureWrite(key) {
-    return pendingSecureWrites.get(key)?.value;
+    return durability.readPendingSecureWrite(key);
   }
   function readPendingDiskWrite(key) {
-    return pendingDiskWrites.get(key)?.value;
+    return durability.readPendingDiskWrite(key);
   }
   function hasPendingDiskWrite(key) {
-    return pendingDiskWrites.has(key);
+    return durability.hasPendingDiskWrite(key);
   }
   function hasPendingSecureWrite(key) {
-    return pendingSecureWrites.has(key);
+    return durability.hasPendingSecureWrite(key);
   }
   function clearPendingDiskWrite(key) {
-    pendingDiskWrites.delete(key);
+    durability.clearPendingDiskWrite(key);
   }
   function clearPendingSecureWrite(key) {
-    pendingSecureWrites.delete(key);
+    durability.clearPendingSecureWrite(key);
   }
   function flushDiskWrites() {
-    diskFlushScheduled = false;
-    if (pendingDiskWrites.size === 0) {
-      return;
-    }
-    const writes = Array.from(pendingDiskWrites.values());
-    pendingDiskWrites.clear();
-    const keysToSet = [];
-    const valuesToSet = [];
-    const keysToRemove = [];
-    writes.forEach(({
-      key,
-      value
-    }) => {
-      if (value === undefined) {
-        keysToRemove.push(key);
-        return;
-      }
-      keysToSet.push(key);
-      valuesToSet.push(value);
-    });
-    if (keysToSet.length > 0) {
-      adapter.backend.setBatch(keysToSet, valuesToSet, _Storage.StorageScope.Disk);
-    }
-    if (keysToRemove.length > 0) {
-      adapter.backend.removeBatch(keysToRemove, _Storage.StorageScope.Disk);
-    }
+    durability.flushDiskWrites();
   }
   function flushSecureWrites() {
-    secureFlushScheduled = false;
-    if (pendingSecureWrites.size === 0) {
-      return;
-    }
-    const writes = Array.from(pendingSecureWrites.values());
-    pendingSecureWrites.clear();
-    const groupedSetWrites = new Map();
-    const keysToRemove = [];
-    writes.forEach(({
-      key,
-      value,
-      accessControl
-    }) => {
-      if (value === undefined) {
-        keysToRemove.push(key);
-      } else {
-        const resolvedAccessControl = accessControl ?? secureDefaultAccessControl;
-        const existingGroup = groupedSetWrites.get(resolvedAccessControl);
-        const group = existingGroup ?? {
-          keys: [],
-          values: []
-        };
-        group.keys.push(key);
-        group.values.push(value);
-        if (!existingGroup) {
-          groupedSetWrites.set(resolvedAccessControl, group);
-        }
-      }
-    });
-    groupedSetWrites.forEach((group, accessControl) => {
-      adapter.backend.setSecureAccessControl(accessControl);
-      adapter.backend.setBatch(group.keys, group.values, _Storage.StorageScope.Secure);
-    });
-    if (keysToRemove.length > 0) {
-      adapter.backend.removeBatch(keysToRemove, _Storage.StorageScope.Secure);
-    }
+    durability.flushSecureWrites();
   }
   function scheduleDiskWrite(key, value) {
-    pendingDiskWrites.set(key, {
-      key,
-      value
-    });
-    if (diskFlushScheduled) {
-      return;
-    }
-    diskFlushScheduled = true;
-    (0, _shared.runMicrotask)(flushDiskWrites);
+    durability.scheduleDiskWrite(key, value);
   }
   function scheduleSecureWrite(key, value, accessControl) {
-    const pendingWrite = {
-      key,
-      value
-    };
-    if (accessControl !== undefined) {
-      pendingWrite.accessControl = accessControl;
-    }
-    pendingSecureWrites.set(key, pendingWrite);
-    if (secureFlushScheduled) {
-      return;
-    }
-    secureFlushScheduled = true;
-    (0, _shared.runMicrotask)(flushSecureWrites);
+    durability.scheduleSecureWrite(key, value, accessControl);
   }
-  function getRawValue(key, scope) {
-    (0, _internal.assertValidScope)(scope);
+  function setDiskWritesAsyncMode(enabled) {
+    durability.setDiskWritesAsync(enabled);
+  }
+  function isDiskWritesAsync() {
+    return durability.isDiskWritesAsync();
+  }
+  function getStoredRawValue(key, scope) {
     if (scope === _Storage.StorageScope.Memory) {
       const value = memoryStore.get(key);
       return typeof value === "string" ? value : undefined;
@@ -268,19 +184,37 @@ function createStorageCore(buildAdapter) {
     }
     return adapter.backend.get(key, scope);
   }
+  function getRawValue(key, scope) {
+    (0, _internal.assertValidScope)(scope);
+    if (scope === _Storage.StorageScope.Memory) {
+      const value = memoryStore.get(key);
+      return typeof value === "string" ? (0, _internal.unescapeCollidingRawValue)(value) : undefined;
+    }
+    if (scope === _Storage.StorageScope.Disk && hasPendingDiskWrite(key)) {
+      const pending = readPendingDiskWrite(key);
+      return pending === undefined ? undefined : (0, _internal.unescapeCollidingRawValue)(pending);
+    }
+    if (scope === _Storage.StorageScope.Secure && hasPendingSecureWrite(key)) {
+      const pending = readPendingSecureWrite(key);
+      return pending === undefined ? undefined : (0, _internal.unescapeCollidingRawValue)(pending);
+    }
+    const raw = adapter.backend.get(key, scope);
+    return raw === undefined ? undefined : (0, _internal.unescapeCollidingRawValue)(raw);
+  }
   function setRawValue(key, value, scope) {
     (0, _internal.assertValidScope)(scope);
+    const storedValue = (0, _internal.escapeCollidingRawValue)(value);
     const oldValue = scope === _Storage.StorageScope.Memory ? getEventRawValue(scope, key) : undefined;
     if (scope === _Storage.StorageScope.Memory) {
-      memoryStore.set(key, value);
+      memoryStore.set(key, storedValue);
       (0, _shared.notifyKeyListeners)(memoryListeners, key);
       emitKeyChange(scope, key, oldValue, value, "set", "memory");
       return;
     }
     if (scope === _Storage.StorageScope.Disk) {
-      cacheRawValue(scope, key, value);
-      if (diskWritesAsync) {
-        scheduleDiskWrite(key, value);
+      cacheRawValue(scope, key, storedValue);
+      if (isDiskWritesAsync()) {
+        scheduleDiskWrite(key, storedValue);
         emitKeyChange(scope, key, oldValue, value, "set", adapter.changeSource);
         return;
       }
@@ -294,8 +228,8 @@ function createStorageCore(buildAdapter) {
         adapter.backend.setSecureAccessControl(secureDefaultAccessControl);
       }
     }
-    adapter.backend.set(key, value, scope);
-    cacheRawValue(scope, key, value);
+    adapter.backend.set(key, storedValue, scope);
+    cacheRawValue(scope, key, storedValue);
     emitKeyChange(scope, key, oldValue, value, "set", adapter.changeSource);
   }
   function removeRawValue(key, scope) {
@@ -309,7 +243,7 @@ function createStorageCore(buildAdapter) {
     }
     if (scope === _Storage.StorageScope.Disk) {
       cacheRawValue(scope, key, undefined);
-      if (diskWritesAsync) {
+      if (isDiskWritesAsync()) {
         scheduleDiskWrite(key, undefined);
         emitKeyChange(scope, key, oldValue, undefined, "remove", adapter.changeSource);
         return;
@@ -333,9 +267,6 @@ function createStorageCore(buildAdapter) {
     const parsed = Number.parseInt(raw, 10);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
   }
-  function writeMigrationVersion(scope, version) {
-    setRawValue(_internal.MIGRATION_VERSION_KEY, String(version), scope);
-  }
   const internals = {
     getScopedListeners,
     cacheRawValue,
@@ -344,10 +275,10 @@ function createStorageCore(buildAdapter) {
     clearPendingDiskWrite,
     clearPendingSecureWrite,
     clearAllPendingDiskWrites: () => {
-      pendingDiskWrites.clear();
+      durability.clearAllPendingDiskWrites();
     },
     clearAllPendingSecureWrites: () => {
-      pendingSecureWrites.clear();
+      durability.clearAllPendingSecureWrites();
     },
     flushDiskWrites,
     flushSecureWrites,
@@ -376,7 +307,9 @@ function createStorageCore(buildAdapter) {
         }
         const previousValues = shouldReadPreviousEventValues(scope) ? removeKeys.map(key => getEventRawValue(scope, key)) : [];
         removeKeys.forEach(key => memoryStore.delete(key));
-        removeKeys.forEach(key => (0, _shared.notifyKeyListeners)(memoryListeners, key));
+        removeKeys.forEach(key => {
+          (0, _shared.notifyKeyListeners)(memoryListeners, key);
+        });
         emitBatchChange(scope, "clear", "memory", removeKeys.map((key, index) => (0, _shared.createKeyChange)(scope, key, previousValues[index], undefined, "clear", "memory")));
         return;
       }
@@ -390,9 +323,11 @@ function createStorageCore(buildAdapter) {
       if (removeKeys.length === 0) {
         return;
       }
-      const previousValues = shouldReadPreviousEventValues(scope) ? adapter.backend.getBatch(removeKeys, scope) : [];
+      const previousValues = shouldReadPreviousEventValues(scope) ? adapter.backend.getBatch(removeKeys, scope).map(value => value === undefined ? undefined : (0, _internal.unescapeCollidingRawValue)(value)) : [];
       adapter.backend.removeBatch(removeKeys, scope);
-      removeKeys.forEach(key => cacheRawValue(scope, key, undefined));
+      removeKeys.forEach(key => {
+        cacheRawValue(scope, key, undefined);
+      });
       emitBatchChange(scope, "clear", adapter.changeSource, removeKeys.map((key, index) => (0, _shared.createKeyChange)(scope, key, previousValues[index], undefined, "clear", adapter.changeSource)));
     });
   }
@@ -462,11 +397,11 @@ function createStorageCore(buildAdapter) {
         }
         if (scope === _Storage.StorageScope.Disk) {
           flushDiskWrites();
-          pendingDiskWrites.clear();
+          durability.clearAllPendingDiskWrites();
         }
         if (scope === _Storage.StorageScope.Secure) {
           flushSecureWrites();
-          pendingSecureWrites.clear();
+          durability.clearAllPendingSecureWrites();
         }
         clearScopeRawCache(scope);
         adapter.backend.clear(scope);
@@ -560,7 +495,9 @@ function createStorageCore(buildAdapter) {
           affectedKeys.forEach(key => {
             memoryStore.delete(key);
           });
-          affectedKeys.forEach(key => (0, _shared.notifyKeyListeners)(memoryListeners, key));
+          affectedKeys.forEach(key => {
+            (0, _shared.notifyKeyListeners)(memoryListeners, key);
+          });
           emitBatchChange(scope, "clearNamespace", "memory", previousValues.map(({
             key,
             value
@@ -661,7 +598,7 @@ function createStorageCore(buildAdapter) {
         keys.forEach((key, idx) => {
           const value = values[idx];
           if (value !== undefined) {
-            result[key] = value;
+            result[key] = (0, _internal.unescapeCollidingRawValue)(value);
           }
         });
         return result;
@@ -674,7 +611,7 @@ function createStorageCore(buildAdapter) {
         if (scope === _Storage.StorageScope.Memory) {
           for (const key of memoryStore.keys()) {
             const value = memoryStore.get(key);
-            if (typeof value === "string") result[key] = value;
+            if (typeof value === "string") result[key] = (0, _internal.unescapeCollidingRawValue)(value);
           }
           return result;
         }
@@ -689,7 +626,7 @@ function createStorageCore(buildAdapter) {
         const values = adapter.backend.getBatch(keys, scope);
         keys.forEach((key, idx) => {
           const val = values[idx];
-          if (val !== undefined) result[key] = val;
+          if (val !== undefined) result[key] = (0, _internal.unescapeCollidingRawValue)(val);
         });
         return result;
       });
@@ -720,7 +657,7 @@ function createStorageCore(buildAdapter) {
     },
     setDiskWritesAsync: enabled => {
       measureOperation("storage:setDiskWritesAsync", _Storage.StorageScope.Disk, () => {
-        diskWritesAsync = enabled;
+        setDiskWritesAsyncMode(enabled);
         if (!enabled) {
           flushDiskWrites();
         }
@@ -737,22 +674,16 @@ function createStorageCore(buildAdapter) {
       });
     },
     setMetricsObserver: observer => {
-      metricsObserver = observer;
+      metrics.setObserver(observer);
     },
     getMetricsSnapshot: () => {
-      const snapshot = {};
-      metricsCounters.forEach((value, key) => {
-        snapshot[key] = {
-          count: value.count,
-          totalDurationMs: value.totalDurationMs,
-          avgDurationMs: value.count === 0 ? 0 : value.totalDurationMs / value.count,
-          maxDurationMs: value.maxDurationMs
-        };
-      });
-      return snapshot;
+      return metrics.getSnapshot();
+    },
+    getScopedMetricsSnapshot: () => {
+      return metrics.getScopedSnapshot();
     },
     resetMetrics: () => {
-      metricsCounters.clear();
+      metrics.reset();
     },
     getSecureMetadata: key => {
       return measureOperation("storage:getSecureMetadata", _Storage.StorageScope.Secure, () => {
@@ -803,12 +734,15 @@ function createStorageCore(buildAdapter) {
         (0, _internal.assertValidScope)(scope);
         if (keys.length === 0) return;
         const values = keys.map(k => data[k]);
+        const storedValues = values.map(_internal.escapeCollidingRawValue);
         const changes = keys.map((key, index) => (0, _shared.createKeyChange)(scope, key, getEventRawValue(scope, key), values[index], "import", scope === _Storage.StorageScope.Memory ? "memory" : adapter.changeSource));
         if (scope === _Storage.StorageScope.Memory) {
           keys.forEach((key, index) => {
-            memoryStore.set(key, values[index]);
+            memoryStore.set(key, storedValues[index]);
+          });
+          keys.forEach(key => {
+            (0, _shared.notifyKeyListeners)(memoryListeners, key);
           });
-          keys.forEach(key => (0, _shared.notifyKeyListeners)(memoryListeners, key));
           emitBatchChange(scope, "import", "memory", changes);
           return;
         }
@@ -816,11 +750,13 @@ function createStorageCore(buildAdapter) {
           flushSecureWrites();
           adapter.backend.setSecureAccessControl(secureDefaultAccessControl);
         }
-        if (scope === _Storage.StorageScope.Disk && adapter.flushDiskWritesOnImport) {
+        if (scope === _Storage.StorageScope.Disk) {
           flushDiskWrites();
         }
-        adapter.backend.setBatch(keys, values, scope);
-        keys.forEach((key, index) => cacheRawValue(scope, key, values[index]));
+        adapter.backend.setBatch(keys, storedValues, scope);
+        keys.forEach((key, index) => {
+          cacheRawValue(scope, key, storedValues[index]);
+        });
         emitBatchChange(scope, "import", adapter.changeSource, changes);
       }, keys.length);
     }
@@ -869,20 +805,28 @@ function createStorageCore(buildAdapter) {
       hasLastValue = false;
       lastExpiresAt = undefined;
     };
+    const resolveNonMemoryScope = () => {
+      if (nonMemoryScope === null) {
+        throw new Error("NitroStorage: this operation requires Disk or Secure scope.");
+      }
+      return nonMemoryScope;
+    };
     const ensureSubscription = () => {
       if (unsubscribe) {
         return;
       }
       const listener = () => {
         invalidateParsedCache();
-        listeners.forEach(callback => callback());
+        listeners.forEach(callback => {
+          callback();
+        });
       };
       if (isMemory) {
         unsubscribe = addKeyListener(memoryListeners, storageKey, listener);
         return;
       }
-      adapter.ensureScopeSubscription(nonMemoryScope);
-      unsubscribe = addKeyListener(getScopedListeners(nonMemoryScope), storageKey, listener);
+      adapter.ensureScopeSubscription(resolveNonMemoryScope());
+      unsubscribe = addKeyListener(getScopedListeners(resolveNonMemoryScope()), storageKey, listener);
     };
     const readStoredRaw = () => {
       if (isMemory) {
@@ -893,28 +837,29 @@ function createStorageCore(buildAdapter) {
             memoryExpiration.delete(storageKey);
             memoryStore.delete(storageKey);
             (0, _shared.notifyKeyListeners)(memoryListeners, storageKey);
-            emitKeyChange(config.scope, storageKey, typeof expiredRaw === "string" ? expiredRaw : undefined, undefined, "expire", "memory");
+            emitKeyChange(config.scope, storageKey, typeof expiredRaw === "string" ? (0, _internal.unescapeCollidingRawValue)(expiredRaw) : undefined, undefined, "expire", "memory");
             onExpired?.(storageKey);
             return undefined;
           }
         }
-        return memoryStore.get(storageKey);
+        const memoryStored = memoryStore.get(storageKey);
+        return typeof memoryStored === "string" ? (0, _internal.unescapeCollidingRawValue)(memoryStored) : memoryStored;
       }
       migrateRenamesIfNeeded();
       if (nonMemoryScope === _Storage.StorageScope.Disk) {
-        const pending = pendingDiskWrites.get(storageKey);
+        const pending = durability.readPendingDiskWrite(storageKey);
         if (pending !== undefined) {
-          return pending.value;
+          return pending;
         }
       }
       if (nonMemoryScope === _Storage.StorageScope.Secure && !isBiometric) {
-        const pending = pendingSecureWrites.get(storageKey);
+        const pending = durability.readPendingSecureWrite(storageKey);
         if (pending !== undefined) {
-          return pending.value;
+          return pending;
         }
       }
       if (readCache) {
-        const cache = getScopeRawCache(nonMemoryScope);
+        const cache = getScopeRawCache(resolveNonMemoryScope());
         const cached = cache.get(storageKey);
         if (cached !== undefined || cache.has(storageKey)) {
           return cached;
@@ -924,7 +869,7 @@ function createStorageCore(buildAdapter) {
         return readBackendRaw(() => adapter.backend.getSecureBiometric(storageKey));
       }
       const raw = readBackendRaw(() => adapter.backend.get(storageKey, config.scope));
-      cacheRawValue(nonMemoryScope, storageKey, raw);
+      cacheRawValue(resolveNonMemoryScope(), storageKey, raw);
       return raw;
     };
     const readBackendRaw = read => {
@@ -933,7 +878,7 @@ function createStorageCore(buildAdapter) {
       } catch (error) {
         onReadError?.(error);
         if (fallbackToCacheOnReadError) {
-          const cached = getScopeRawCache(nonMemoryScope).get(storageKey);
+          const cached = getScopeRawCache(resolveNonMemoryScope()).get(storageKey);
           if (cached !== undefined) {
             return cached;
           }
@@ -949,9 +894,9 @@ function createStorageCore(buildAdapter) {
         emitKeyChange(config.scope, storageKey, oldValue, rawValue, "set", adapter.changeSource);
         return;
       }
-      cacheRawValue(nonMemoryScope, storageKey, rawValue);
+      cacheRawValue(resolveNonMemoryScope(), storageKey, rawValue);
       if (nonMemoryScope === _Storage.StorageScope.Disk) {
-        if (coalesceDiskWrites || diskWritesAsync) {
+        if (coalesceDiskWrites || isDiskWritesAsync()) {
           scheduleDiskWrite(storageKey, rawValue);
           emitKeyChange(config.scope, storageKey, oldValue, rawValue, "set", adapter.changeSource);
           return;
@@ -1020,9 +965,9 @@ function createStorageCore(buildAdapter) {
         emitKeyChange(config.scope, storageKey, oldValue, undefined, operation, adapter.changeSource);
         return;
       }
-      cacheRawValue(nonMemoryScope, storageKey, undefined);
+      cacheRawValue(resolveNonMemoryScope(), storageKey, undefined);
       if (nonMemoryScope === _Storage.StorageScope.Disk) {
-        if (coalesceDiskWrites || diskWritesAsync) {
+        if (coalesceDiskWrites || isDiskWritesAsync()) {
           scheduleDiskWrite(storageKey, undefined);
           emitKeyChange(config.scope, storageKey, oldValue, undefined, operation, adapter.changeSource);
           return;
@@ -1046,7 +991,8 @@ function createStorageCore(buildAdapter) {
         if (memoryExpiration) {
           memoryExpiration.set(storageKey, Date.now() + (expirationTtlMs ?? 0));
         }
-        memoryStore.set(storageKey, value);
+        const storedValue = typeof value === "string" ? (0, _internal.escapeCollidingRawValue)(value) : value;
+        memoryStore.set(storageKey, storedValue);
         (0, _shared.notifyKeyListeners)(memoryListeners, storageKey);
         emitKeyChange(config.scope, storageKey, oldValue, typeof value === "string" ? value : undefined, "set", "memory");
         return;
@@ -1097,7 +1043,9 @@ function createStorageCore(buildAdapter) {
           onExpired?.(storageKey);
           lastValue = ensureValidatedValue(defaultValue, false);
           hasLastValue = true;
-          listeners.forEach(cb => cb());
+          listeners.forEach(cb => {
+            cb();
+          });
           return lastValue;
         }
       }
@@ -1133,7 +1081,9 @@ function createStorageCore(buildAdapter) {
               onExpired?.(storageKey);
               lastValue = ensureValidatedValue(defaultValue, false);
               hasLastValue = true;
-              listeners.forEach(cb => cb());
+              listeners.forEach(cb => {
+                cb();
+              });
               return lastValue;
             }
             deserializableRaw = parsed.payload;
@@ -1151,7 +1101,10 @@ function createStorageCore(buildAdapter) {
     };
     const getCurrentVersion = () => {
       const raw = readStoredRaw();
-      return (0, _internal.toVersionToken)(raw);
+      if (raw === undefined) {
+        return (0, _internal.toVersionToken)(undefined);
+      }
+      return (0, _internal.toVersionToken)(typeof raw === "string" ? (0, _internal.unescapeCollidingRawValue)(raw) : raw);
     };
     const get = () => measureOperation("item:get", config.scope, () => getInternal());
     const getWithVersion = () => measureOperation("item:getWithVersion", config.scope, () => ({
@@ -1217,15 +1170,13 @@ function createStorageCore(buildAdapter) {
       if (isMemory) return memoryStore.has(storageKey);
       if (isBiometric) return adapter.backend.hasSecureBiometric(storageKey);
       if (nonMemoryScope === _Storage.StorageScope.Disk) {
-        const pending = pendingDiskWrites.get(storageKey);
-        if (pending !== undefined) {
-          return pending.value !== undefined;
+        if (durability.hasPendingDiskWrite(storageKey)) {
+          return durability.readPendingDiskWrite(storageKey) !== undefined;
         }
       }
       if (nonMemoryScope === _Storage.StorageScope.Secure) {
-        const pending = pendingSecureWrites.get(storageKey);
-        if (pending !== undefined) {
-          return pending.value !== undefined;
+        if (durability.hasPendingSecureWrite(storageKey)) {
+          return durability.readPendingSecureWrite(storageKey) !== undefined;
         }
       }
       return adapter.backend.has(storageKey, config.scope);
@@ -1238,7 +1189,7 @@ function createStorageCore(buildAdapter) {
         if (listeners.size === 0 && unsubscribe) {
           unsubscribe();
           if (!isMemory) {
-            adapter.maybeCleanupScopeSubscription(nonMemoryScope);
+            adapter.maybeCleanupScopeSubscription(resolveNonMemoryScope());
           }
           unsubscribe = null;
         }
@@ -1276,11 +1227,20 @@ function createStorageCore(buildAdapter) {
       deserialize,
       _triggerListeners: () => {
         invalidateParsedCache();
-        listeners.forEach(listener => listener());
+        listeners.forEach(listener => {
+          listener();
+        });
       },
       _invalidateParsedCacheOnly: () => {
         invalidateParsedCache();
       },
+      _deleteMemoryEntry: () => {
+        if (memoryExpiration) {
+          memoryExpiration.delete(storageKey);
+        }
+        memoryStore.delete(storageKey);
+        invalidateParsedCache();
+      },
       _hasValidation: validate !== undefined,
       _hasExpiration: expiration !== undefined,
       _readCacheEnabled: readCache,
@@ -1323,16 +1283,16 @@ function createStorageCore(buildAdapter) {
       const keyIndexes = [];
       items.forEach((item, index) => {
         if (scope === _Storage.StorageScope.Disk) {
-          const pending = pendingDiskWrites.get(item.key);
+          const pending = durability.readPendingDiskWrite(item.key);
           if (pending !== undefined) {
-            rawValues[index] = pending.value;
+            rawValues[index] = pending;
             return;
           }
         }
         if (scope === _Storage.StorageScope.Secure) {
-          const pending = pendingSecureWrites.get(item.key);
+          const pending = durability.readPendingSecureWrite(item.key);
           if (pending !== undefined) {
-            rawValues[index] = pending.value;
+            rawValues[index] = pending;
             return;
           }
         }
@@ -1384,7 +1344,9 @@ function createStorageCore(buildAdapter) {
           items.forEach(({
             item,
             value
-          }) => item.set(value));
+          }) => {
+            item.set(value);
+          });
           return;
         }
         const changes = items.map(({
@@ -1402,7 +1364,9 @@ function createStorageCore(buildAdapter) {
         });
         items.forEach(({
           item
-        }) => (0, _shared.notifyKeyListeners)(memoryListeners, item.key));
+        }) => {
+          (0, _shared.notifyKeyListeners)(memoryListeners, item.key);
+        });
         emitBatchChange(scope, "setBatch", "memory", changes);
         return;
       }
@@ -1422,14 +1386,16 @@ function createStorageCore(buildAdapter) {
           items.forEach(({
             item,
             value
-          }) => item.set(value));
+          }) => {
+            item.set(value);
+          });
           return;
         }
         flushSecureWrites();
         const keys = secureEntries.map(({
           item
         }) => item.key);
-        const oldValues = shouldReadPreviousEventValues(scope) ? adapter.backend.getBatch(keys, scope) : [];
+        const oldValues = shouldReadPreviousEventValues(scope) ? adapter.backend.getBatch(keys, scope).map(value => value === undefined ? undefined : (0, _internal.unescapeCollidingRawValue)(value)) : [];
         const groupedByAccessControl = new Map();
         secureEntries.forEach(({
           item,
@@ -1451,7 +1417,9 @@ function createStorageCore(buildAdapter) {
         groupedByAccessControl.forEach((group, accessControl) => {
           adapter.backend.setSecureAccessControl(accessControl);
           adapter.backend.setBatch(group.keys, group.values, scope);
-          group.keys.forEach((key, index) => cacheRawValue(scope, key, group.values[index]));
+          group.keys.forEach((key, index) => {
+            cacheRawValue(scope, key, group.values[index]);
+          });
         });
         emitBatchChange(scope, "setBatch", adapter.changeSource, secureEntries.map(({
           item,
@@ -1467,14 +1435,18 @@ function createStorageCore(buildAdapter) {
         items.forEach(({
           item,
           value
-        }) => item.set(value));
+        }) => {
+          item.set(value);
+        });
         return;
       }
       const keys = items.map(entry => entry.item.key);
       const values = items.map(entry => entry.item.serialize(entry.value));
-      const oldValues = shouldReadPreviousEventValues(scope) ? adapter.backend.getBatch(keys, scope) : [];
+      const oldValues = shouldReadPreviousEventValues(scope) ? adapter.backend.getBatch(keys, scope).map(value => value === undefined ? undefined : (0, _internal.unescapeCollidingRawValue)(value)) : [];
       adapter.backend.setBatch(keys, values, scope);
-      keys.forEach((key, index) => cacheRawValue(scope, key, values[index]));
+      keys.forEach((key, index) => {
+        cacheRawValue(scope, key, values[index]);
+      });
       emitBatchChange(scope, "setBatch", adapter.changeSource, keys.map((key, index) => (0, _shared.createKeyChange)(scope, key, oldValues[index], values[index], "setBatch", adapter.changeSource)));
     }, items.length);
   }
@@ -1483,7 +1455,12 @@ function createStorageCore(buildAdapter) {
       (0, _internal.assertBatchScope)(items, scope);
       if (scope === _Storage.StorageScope.Memory) {
         const changes = items.map(item => (0, _shared.createKeyChange)(scope, item.key, getEventRawValue(scope, item.key), undefined, "removeBatch", "memory"));
-        items.forEach(item => item.delete());
+        items.forEach(item => {
+          asInternal(item)._deleteMemoryEntry();
+        });
+        items.forEach(item => {
+          (0, _shared.notifyKeyListeners)(memoryListeners, item.key);
+        });
         emitBatchChange(scope, "removeBatch", "memory", changes);
         return;
       }
@@ -1494,9 +1471,11 @@ function createStorageCore(buildAdapter) {
       if (scope === _Storage.StorageScope.Secure) {
         flushSecureWrites();
       }
-      const oldValues = shouldReadPreviousEventValues(scope) ? adapter.backend.getBatch(keys, scope) : [];
+      const oldValues = shouldReadPreviousEventValues(scope) ? adapter.backend.getBatch(keys, scope).map(value => value === undefined ? undefined : (0, _internal.unescapeCollidingRawValue)(value)) : [];
       adapter.backend.removeBatch(keys, scope);
-      keys.forEach(key => cacheRawValue(scope, key, undefined));
+      keys.forEach(key => {
+        cacheRawValue(scope, key, undefined);
+      });
       emitBatchChange(scope, "removeBatch", adapter.changeSource, keys.map((key, index) => (0, _shared.createKeyChange)(scope, key, oldValues[index], undefined, "removeBatch", adapter.changeSource)));
     }, items.length);
   }
@@ -1515,23 +1494,17 @@ function createStorageCore(buildAdapter) {
       const currentVersion = readMigrationVersion(scope);
       const versions = Array.from(registeredMigrations.keys()).filter(version => version > currentVersion).sort((a, b) => a - b);
       let appliedVersion = currentVersion;
-      const context = {
-        scope,
-        getRaw: key => getRawValue(key, scope),
-        setRaw: (key, value) => setRawValue(key, value, scope),
-        removeRaw: key => removeRawValue(key, scope)
-      };
       versions.forEach(version => {
         const migration = registeredMigrations.get(version);
         if (!migration) {
           return;
         }
-        migration(context);
+        runTransaction(scope, tx => {
+          migration(tx);
+          tx.setRaw(_internal.MIGRATION_VERSION_KEY, String(version));
+        });
         appliedVersion = version;
       });
-      if (appliedVersion !== currentVersion) {
-        writeMigrationVersion(scope, appliedVersion);
-      }
       return appliedVersion;
     });
   }
@@ -1567,7 +1540,7 @@ function createStorageCore(buildAdapter) {
           }
           rollback.set(key, {
             kind: "raw",
-            value: getRawValue(key, scope),
+            value: getStoredRawValue(key, scope),
             ...(scope === _Storage.StorageScope.Secure && internal?._secureAccessControl !== undefined ? {
               accessControl: internal._secureAccessControl
             } : {})
@@ -1604,6 +1577,8 @@ function createStorageCore(buildAdapter) {
         return transaction(tx);
       } catch (error) {
         const rollbackEntries = Array.from(rollback.entries()).reverse();
+        const rollbackSource = scope === _Storage.StorageScope.Memory ? "memory" : adapter.changeSource;
+        const preRollbackValues = rollbackEntries.length > 0 ? rollbackEntries.map(([key]) => getEventRawValue(scope, key)) : [];
         if (scope === _Storage.StorageScope.Memory) {
           rollbackEntries.forEach(([key, record]) => {
             if (record.value === NOT_SET) {
@@ -1655,13 +1630,20 @@ function createStorageCore(buildAdapter) {
               adapter.backend.setSecureAccessControl(accessControl);
             }
             adapter.backend.setBatch(group.keys, group.values, scope);
-            group.keys.forEach((key, index) => cacheRawValue(scope, key, group.values[index]));
+            group.keys.forEach((key, index) => {
+              cacheRawValue(scope, key, group.values[index]);
+            });
           });
           if (keysToRemove.length > 0) {
             adapter.backend.removeBatch(keysToRemove, scope);
-            keysToRemove.forEach(key => cacheRawValue(scope, key, undefined));
+            keysToRemove.forEach(key => {
+              cacheRawValue(scope, key, undefined);
+            });
           }
         }
+        if (rollbackEntries.length > 0) {
+          emitBatchChange(scope, "rollback", rollbackSource, rollbackEntries.map(([key], index) => (0, _shared.createKeyChange)(scope, key, preRollbackValues[index], getEventRawValue(scope, key), "rollback", rollbackSource)));
+        }
         throw error;
       }
     });
@@ -1739,12 +1721,15 @@ function createStorageCore(buildAdapter) {
     });
     const has = id => item.get()[id] === true;
     const add = id => {
-      if (item.get()[id] === true) {
+      const current = item.get();
+      if (current[id] === true) {
         return;
       }
-      item.merge({
-        [id]: true
-      });
+      const next = {
+        ...current
+      };
+      next[id] = true;
+      item.set(next);
     };
     const deleteId = id => {
       const current = item.get();
@@ -1773,7 +1758,9 @@ function createStorageCore(buildAdapter) {
       toggle,
       values: () => Object.keys(item.get()),
       size: () => Object.keys(item.get()).length,
-      clear: () => item.set({}),
+      clear: () => {
+        item.set({});
+      },
       reset: item.reset,
       subscribe: item.subscribe,
       scope: item.scope,