react-native-nitro-storage 0.7.0 → 0.9.0

package/lib/module/storage-core.js

@@ -1,9 +1,11 @@
 "use strict";
 
-import { assertAccessControlLevel, assertBiometricLevel, canUseRawBatchPath, canUseSecureRawBatchPath, createKeyChange, defaultDeserialize, defaultSerialize, isKeychainLockedError, isUpdater, notifyAllListeners, notifyKeyListeners, now, redactSecureKeyChange, runMicrotask, typedKeys } from "./shared";
-import { StorageScope, AccessControl, BiometricLevel } from "./Storage.types";
-import { MIGRATION_VERSION_KEY, isStoredEnvelope, assertBatchScope, assertValidScope, toVersionToken, prefixKey, isNamespaced } from "./internal";
+import { createDurabilityCoordinator } from "./core/durability";
+import { createMetricsRegistry } from "./core/metrics";
+import { MIGRATION_VERSION_KEY, isStoredEnvelope, assertBatchScope, assertValidScope, toVersionToken, prefixKey, isNamespaced, escapeCollidingRawValue, unescapeCollidingRawValue } from "./internal";
+import { assertAccessControlLevel, assertBiometricLevel, canUseRawBatchPath, canUseSecureRawBatchPath, createKeyChange, defaultDeserialize, defaultSerialize, isKeychainLockedError, isUpdater, notifyAllListeners, notifyKeyListeners, redactSecureKeyChange, typedKeys } from "./shared";
 import { StorageEventRegistry } from "./storage-events";
+import { StorageScope, AccessControl, BiometricLevel } from "./Storage.types";
 const EMPTY_KEYS = Object.freeze([]);
 function asInternal(item) {
   return item;
@@ -14,55 +16,38 @@ export function createStorageCore(buildAdapter) {
   const registeredKeyCounts = new Map();
   const memoryStore = new Map();
   const memoryListeners = new Map();
-  const scopedListeners = new Map([[StorageScope.Disk, new Map()], [StorageScope.Secure, new Map()]]);
-  const scopedRawCache = new Map([[StorageScope.Disk, new Map()], [StorageScope.Secure, new Map()]]);
-  const pendingDiskWrites = new Map();
-  let diskFlushScheduled = false;
-  let diskWritesAsync = false;
-  const pendingSecureWrites = new Map();
-  let secureFlushScheduled = false;
+  const scopedListeners = {
+    [StorageScope.Disk]: new Map(),
+    [StorageScope.Secure]: new Map()
+  };
+  const scopedRawCache = {
+    [StorageScope.Disk]: new Map(),
+    [StorageScope.Secure]: new Map()
+  };
   let secureDefaultAccessControl = AccessControl.WhenUnlocked;
-  let metricsObserver;
   let eventObserver;
   let eventObserverRedactSecureValues = true;
-  const metricsCounters = new Map();
   const storageEvents = new 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 = now();
-    try {
-      return fn();
-    } finally {
-      recordMetric(operation, scope, now() - start, keysCount);
-    }
-  }
+  const metrics = createMetricsRegistry();
+  const 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);
@@ -94,7 +79,7 @@ export function createStorageCore(buildAdapter) {
   function getEventRawValue(scope, key) {
     if (scope === StorageScope.Memory) {
       const value = memoryStore.get(key);
-      return typeof value === "string" ? value : undefined;
+      return typeof value === "string" ? unescapeCollidingRawValue(value) : undefined;
     }
     return getRawValue(key, scope);
   }
@@ -140,118 +125,49 @@ export 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, StorageScope.Disk);
-    }
-    if (keysToRemove.length > 0) {
-      adapter.backend.removeBatch(keysToRemove, 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, StorageScope.Secure);
-    });
-    if (keysToRemove.length > 0) {
-      adapter.backend.removeBatch(keysToRemove, StorageScope.Secure);
-    }
+    durability.flushSecureWrites();
   }
   function scheduleDiskWrite(key, value) {
-    pendingDiskWrites.set(key, {
-      key,
-      value
-    });
-    if (diskFlushScheduled) {
-      return;
-    }
-    diskFlushScheduled = true;
-    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;
-    runMicrotask(flushSecureWrites);
+    durability.scheduleSecureWrite(key, value, accessControl);
   }
-  function getRawValue(key, scope) {
-    assertValidScope(scope);
+  function setDiskWritesAsyncMode(enabled) {
+    durability.setDiskWritesAsync(enabled);
+  }
+  function isDiskWritesAsync() {
+    return durability.isDiskWritesAsync();
+  }
+  function getStoredRawValue(key, scope) {
     if (scope === StorageScope.Memory) {
       const value = memoryStore.get(key);
       return typeof value === "string" ? value : undefined;
@@ -264,19 +180,37 @@ export function createStorageCore(buildAdapter) {
     }
     return adapter.backend.get(key, scope);
   }
+  function getRawValue(key, scope) {
+    assertValidScope(scope);
+    if (scope === StorageScope.Memory) {
+      const value = memoryStore.get(key);
+      return typeof value === "string" ? unescapeCollidingRawValue(value) : undefined;
+    }
+    if (scope === StorageScope.Disk && hasPendingDiskWrite(key)) {
+      const pending = readPendingDiskWrite(key);
+      return pending === undefined ? undefined : unescapeCollidingRawValue(pending);
+    }
+    if (scope === StorageScope.Secure && hasPendingSecureWrite(key)) {
+      const pending = readPendingSecureWrite(key);
+      return pending === undefined ? undefined : unescapeCollidingRawValue(pending);
+    }
+    const raw = adapter.backend.get(key, scope);
+    return raw === undefined ? undefined : unescapeCollidingRawValue(raw);
+  }
   function setRawValue(key, value, scope) {
     assertValidScope(scope);
+    const storedValue = escapeCollidingRawValue(value);
     const oldValue = scope === StorageScope.Memory ? getEventRawValue(scope, key) : undefined;
     if (scope === StorageScope.Memory) {
-      memoryStore.set(key, value);
+      memoryStore.set(key, storedValue);
       notifyKeyListeners(memoryListeners, key);
       emitKeyChange(scope, key, oldValue, value, "set", "memory");
       return;
     }
     if (scope === 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;
       }
@@ -290,8 +224,8 @@ export 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) {
@@ -305,7 +239,7 @@ export function createStorageCore(buildAdapter) {
     }
     if (scope === StorageScope.Disk) {
       cacheRawValue(scope, key, undefined);
-      if (diskWritesAsync) {
+      if (isDiskWritesAsync()) {
         scheduleDiskWrite(key, undefined);
         emitKeyChange(scope, key, oldValue, undefined, "remove", adapter.changeSource);
         return;
@@ -329,9 +263,6 @@ export function createStorageCore(buildAdapter) {
     const parsed = Number.parseInt(raw, 10);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
   }
-  function writeMigrationVersion(scope, version) {
-    setRawValue(MIGRATION_VERSION_KEY, String(version), scope);
-  }
   const internals = {
     getScopedListeners,
     cacheRawValue,
@@ -340,10 +271,10 @@ export function createStorageCore(buildAdapter) {
     clearPendingDiskWrite,
     clearPendingSecureWrite,
     clearAllPendingDiskWrites: () => {
-      pendingDiskWrites.clear();
+      durability.clearAllPendingDiskWrites();
     },
     clearAllPendingSecureWrites: () => {
-      pendingSecureWrites.clear();
+      durability.clearAllPendingSecureWrites();
     },
     flushDiskWrites,
     flushSecureWrites,
@@ -372,7 +303,9 @@ export function createStorageCore(buildAdapter) {
         }
         const previousValues = shouldReadPreviousEventValues(scope) ? removeKeys.map(key => getEventRawValue(scope, key)) : [];
         removeKeys.forEach(key => memoryStore.delete(key));
-        removeKeys.forEach(key => notifyKeyListeners(memoryListeners, key));
+        removeKeys.forEach(key => {
+          notifyKeyListeners(memoryListeners, key);
+        });
         emitBatchChange(scope, "clear", "memory", removeKeys.map((key, index) => createKeyChange(scope, key, previousValues[index], undefined, "clear", "memory")));
         return;
       }
@@ -386,9 +319,11 @@ export 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 : 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) => createKeyChange(scope, key, previousValues[index], undefined, "clear", adapter.changeSource)));
     });
   }
@@ -458,11 +393,11 @@ export function createStorageCore(buildAdapter) {
         }
         if (scope === StorageScope.Disk) {
           flushDiskWrites();
-          pendingDiskWrites.clear();
+          durability.clearAllPendingDiskWrites();
         }
         if (scope === StorageScope.Secure) {
           flushSecureWrites();
-          pendingSecureWrites.clear();
+          durability.clearAllPendingSecureWrites();
         }
         clearScopeRawCache(scope);
         adapter.backend.clear(scope);
@@ -556,7 +491,9 @@ export function createStorageCore(buildAdapter) {
           affectedKeys.forEach(key => {
             memoryStore.delete(key);
           });
-          affectedKeys.forEach(key => notifyKeyListeners(memoryListeners, key));
+          affectedKeys.forEach(key => {
+            notifyKeyListeners(memoryListeners, key);
+          });
           emitBatchChange(scope, "clearNamespace", "memory", previousValues.map(({
             key,
             value
@@ -657,7 +594,7 @@ export function createStorageCore(buildAdapter) {
         keys.forEach((key, idx) => {
           const value = values[idx];
           if (value !== undefined) {
-            result[key] = value;
+            result[key] = unescapeCollidingRawValue(value);
           }
         });
         return result;
@@ -670,7 +607,7 @@ export function createStorageCore(buildAdapter) {
         if (scope === 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] = unescapeCollidingRawValue(value);
           }
           return result;
         }
@@ -685,7 +622,7 @@ export 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] = unescapeCollidingRawValue(val);
         });
         return result;
       });
@@ -716,7 +653,7 @@ export function createStorageCore(buildAdapter) {
     },
     setDiskWritesAsync: enabled => {
       measureOperation("storage:setDiskWritesAsync", StorageScope.Disk, () => {
-        diskWritesAsync = enabled;
+        setDiskWritesAsyncMode(enabled);
         if (!enabled) {
           flushDiskWrites();
         }
@@ -733,22 +670,16 @@ export 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", StorageScope.Secure, () => {
@@ -799,12 +730,15 @@ export function createStorageCore(buildAdapter) {
         assertValidScope(scope);
         if (keys.length === 0) return;
         const values = keys.map(k => data[k]);
+        const storedValues = values.map(escapeCollidingRawValue);
         const changes = keys.map((key, index) => createKeyChange(scope, key, getEventRawValue(scope, key), values[index], "import", scope === StorageScope.Memory ? "memory" : adapter.changeSource));
         if (scope === StorageScope.Memory) {
           keys.forEach((key, index) => {
-            memoryStore.set(key, values[index]);
+            memoryStore.set(key, storedValues[index]);
+          });
+          keys.forEach(key => {
+            notifyKeyListeners(memoryListeners, key);
           });
-          keys.forEach(key => notifyKeyListeners(memoryListeners, key));
           emitBatchChange(scope, "import", "memory", changes);
           return;
         }
@@ -812,11 +746,13 @@ export function createStorageCore(buildAdapter) {
           flushSecureWrites();
           adapter.backend.setSecureAccessControl(secureDefaultAccessControl);
         }
-        if (scope === StorageScope.Disk && adapter.flushDiskWritesOnImport) {
+        if (scope === 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);
     }
@@ -865,20 +801,28 @@ export 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) {
@@ -889,28 +833,29 @@ export function createStorageCore(buildAdapter) {
             memoryExpiration.delete(storageKey);
             memoryStore.delete(storageKey);
             notifyKeyListeners(memoryListeners, storageKey);
-            emitKeyChange(config.scope, storageKey, typeof expiredRaw === "string" ? expiredRaw : undefined, undefined, "expire", "memory");
+            emitKeyChange(config.scope, storageKey, typeof expiredRaw === "string" ? unescapeCollidingRawValue(expiredRaw) : undefined, undefined, "expire", "memory");
             onExpired?.(storageKey);
             return undefined;
           }
         }
-        return memoryStore.get(storageKey);
+        const memoryStored = memoryStore.get(storageKey);
+        return typeof memoryStored === "string" ? unescapeCollidingRawValue(memoryStored) : memoryStored;
       }
       migrateRenamesIfNeeded();
       if (nonMemoryScope === StorageScope.Disk) {
-        const pending = pendingDiskWrites.get(storageKey);
+        const pending = durability.readPendingDiskWrite(storageKey);
         if (pending !== undefined) {
-          return pending.value;
+          return pending;
         }
       }
       if (nonMemoryScope === 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;
@@ -920,7 +865,7 @@ export 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 => {
@@ -929,7 +874,7 @@ export 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;
           }
@@ -945,9 +890,9 @@ export function createStorageCore(buildAdapter) {
         emitKeyChange(config.scope, storageKey, oldValue, rawValue, "set", adapter.changeSource);
         return;
       }
-      cacheRawValue(nonMemoryScope, storageKey, rawValue);
+      cacheRawValue(resolveNonMemoryScope(), storageKey, rawValue);
       if (nonMemoryScope === StorageScope.Disk) {
-        if (coalesceDiskWrites || diskWritesAsync) {
+        if (coalesceDiskWrites || isDiskWritesAsync()) {
           scheduleDiskWrite(storageKey, rawValue);
           emitKeyChange(config.scope, storageKey, oldValue, rawValue, "set", adapter.changeSource);
           return;
@@ -1016,9 +961,9 @@ export function createStorageCore(buildAdapter) {
         emitKeyChange(config.scope, storageKey, oldValue, undefined, operation, adapter.changeSource);
         return;
       }
-      cacheRawValue(nonMemoryScope, storageKey, undefined);
+      cacheRawValue(resolveNonMemoryScope(), storageKey, undefined);
       if (nonMemoryScope === StorageScope.Disk) {
-        if (coalesceDiskWrites || diskWritesAsync) {
+        if (coalesceDiskWrites || isDiskWritesAsync()) {
           scheduleDiskWrite(storageKey, undefined);
           emitKeyChange(config.scope, storageKey, oldValue, undefined, operation, adapter.changeSource);
           return;
@@ -1042,7 +987,8 @@ export function createStorageCore(buildAdapter) {
         if (memoryExpiration) {
           memoryExpiration.set(storageKey, Date.now() + (expirationTtlMs ?? 0));
         }
-        memoryStore.set(storageKey, value);
+        const storedValue = typeof value === "string" ? escapeCollidingRawValue(value) : value;
+        memoryStore.set(storageKey, storedValue);
         notifyKeyListeners(memoryListeners, storageKey);
         emitKeyChange(config.scope, storageKey, oldValue, typeof value === "string" ? value : undefined, "set", "memory");
         return;
@@ -1093,7 +1039,9 @@ export function createStorageCore(buildAdapter) {
           onExpired?.(storageKey);
           lastValue = ensureValidatedValue(defaultValue, false);
           hasLastValue = true;
-          listeners.forEach(cb => cb());
+          listeners.forEach(cb => {
+            cb();
+          });
           return lastValue;
         }
       }
@@ -1129,7 +1077,9 @@ export function createStorageCore(buildAdapter) {
               onExpired?.(storageKey);
               lastValue = ensureValidatedValue(defaultValue, false);
               hasLastValue = true;
-              listeners.forEach(cb => cb());
+              listeners.forEach(cb => {
+                cb();
+              });
               return lastValue;
             }
             deserializableRaw = parsed.payload;
@@ -1147,7 +1097,10 @@ export function createStorageCore(buildAdapter) {
     };
     const getCurrentVersion = () => {
       const raw = readStoredRaw();
-      return toVersionToken(raw);
+      if (raw === undefined) {
+        return toVersionToken(undefined);
+      }
+      return toVersionToken(typeof raw === "string" ? unescapeCollidingRawValue(raw) : raw);
     };
     const get = () => measureOperation("item:get", config.scope, () => getInternal());
     const getWithVersion = () => measureOperation("item:getWithVersion", config.scope, () => ({
@@ -1213,15 +1166,13 @@ export function createStorageCore(buildAdapter) {
       if (isMemory) return memoryStore.has(storageKey);
       if (isBiometric) return adapter.backend.hasSecureBiometric(storageKey);
       if (nonMemoryScope === 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 === 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);
@@ -1234,7 +1185,7 @@ export function createStorageCore(buildAdapter) {
         if (listeners.size === 0 && unsubscribe) {
           unsubscribe();
           if (!isMemory) {
-            adapter.maybeCleanupScopeSubscription(nonMemoryScope);
+            adapter.maybeCleanupScopeSubscription(resolveNonMemoryScope());
           }
           unsubscribe = null;
         }
@@ -1272,11 +1223,20 @@ export 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,
@@ -1319,16 +1279,16 @@ export function createStorageCore(buildAdapter) {
       const keyIndexes = [];
       items.forEach((item, index) => {
         if (scope === 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 === 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;
           }
         }
@@ -1380,7 +1340,9 @@ export function createStorageCore(buildAdapter) {
           items.forEach(({
             item,
             value
-          }) => item.set(value));
+          }) => {
+            item.set(value);
+          });
           return;
         }
         const changes = items.map(({
@@ -1398,7 +1360,9 @@ export function createStorageCore(buildAdapter) {
         });
         items.forEach(({
           item
-        }) => notifyKeyListeners(memoryListeners, item.key));
+        }) => {
+          notifyKeyListeners(memoryListeners, item.key);
+        });
         emitBatchChange(scope, "setBatch", "memory", changes);
         return;
       }
@@ -1418,14 +1382,16 @@ export 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 : unescapeCollidingRawValue(value)) : [];
         const groupedByAccessControl = new Map();
         secureEntries.forEach(({
           item,
@@ -1447,7 +1413,9 @@ export 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,
@@ -1463,14 +1431,18 @@ export 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 : 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) => createKeyChange(scope, key, oldValues[index], values[index], "setBatch", adapter.changeSource)));
     }, items.length);
   }
@@ -1479,7 +1451,12 @@ export function createStorageCore(buildAdapter) {
       assertBatchScope(items, scope);
       if (scope === StorageScope.Memory) {
         const changes = items.map(item => 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 => {
+          notifyKeyListeners(memoryListeners, item.key);
+        });
         emitBatchChange(scope, "removeBatch", "memory", changes);
         return;
       }
@@ -1490,9 +1467,11 @@ export function createStorageCore(buildAdapter) {
       if (scope === 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 : 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) => createKeyChange(scope, key, oldValues[index], undefined, "removeBatch", adapter.changeSource)));
     }, items.length);
   }
@@ -1511,23 +1490,17 @@ export 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(MIGRATION_VERSION_KEY, String(version));
+        });
         appliedVersion = version;
       });
-      if (appliedVersion !== currentVersion) {
-        writeMigrationVersion(scope, appliedVersion);
-      }
       return appliedVersion;
     });
   }
@@ -1563,7 +1536,7 @@ export function createStorageCore(buildAdapter) {
           }
           rollback.set(key, {
             kind: "raw",
-            value: getRawValue(key, scope),
+            value: getStoredRawValue(key, scope),
             ...(scope === StorageScope.Secure && internal?._secureAccessControl !== undefined ? {
               accessControl: internal._secureAccessControl
             } : {})
@@ -1600,6 +1573,8 @@ export function createStorageCore(buildAdapter) {
         return transaction(tx);
       } catch (error) {
         const rollbackEntries = Array.from(rollback.entries()).reverse();
+        const rollbackSource = scope === StorageScope.Memory ? "memory" : adapter.changeSource;
+        const preRollbackValues = rollbackEntries.length > 0 ? rollbackEntries.map(([key]) => getEventRawValue(scope, key)) : [];
         if (scope === StorageScope.Memory) {
           rollbackEntries.forEach(([key, record]) => {
             if (record.value === NOT_SET) {
@@ -1651,13 +1626,20 @@ export 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) => createKeyChange(scope, key, preRollbackValues[index], getEventRawValue(scope, key), "rollback", rollbackSource)));
+        }
         throw error;
       }
     });
@@ -1735,12 +1717,15 @@ export 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();
@@ -1769,7 +1754,9 @@ export 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,