react-native-nitro-storage 0.3.1 → 0.4.0

package/lib/commonjs/index.web.js

@@ -24,6 +24,7 @@ Object.defineProperty(exports, "StorageScope", {
 exports.createSecureAuthStorage = createSecureAuthStorage;
 exports.createStorageItem = createStorageItem;
 exports.getBatch = getBatch;
+exports.getWebSecureStorageBackend = getWebSecureStorageBackend;
 Object.defineProperty(exports, "migrateFromMMKV", {
   enumerable: true,
   get: function () {
@@ -35,17 +36,39 @@ exports.registerMigration = registerMigration;
 exports.removeBatch = removeBatch;
 exports.runTransaction = runTransaction;
 exports.setBatch = setBatch;
+exports.setWebSecureStorageBackend = setWebSecureStorageBackend;
 exports.storage = void 0;
-exports.useSetStorage = useSetStorage;
-exports.useStorage = useStorage;
-exports.useStorageSelector = useStorageSelector;
-var _react = require("react");
+Object.defineProperty(exports, "useSetStorage", {
+  enumerable: true,
+  get: function () {
+    return _storageHooks.useSetStorage;
+  }
+});
+Object.defineProperty(exports, "useStorage", {
+  enumerable: true,
+  get: function () {
+    return _storageHooks.useStorage;
+  }
+});
+Object.defineProperty(exports, "useStorageSelector", {
+  enumerable: true,
+  get: function () {
+    return _storageHooks.useStorageSelector;
+  }
+});
 var _Storage = require("./Storage.types");
 var _internal = require("./internal");
 var _migration = require("./migration");
+var _storageHooks = require("./storage-hooks");
 function asInternal(item) {
   return item;
 }
+function isUpdater(valueOrFn) {
+  return typeof valueOrFn === "function";
+}
+function typedKeys(record) {
+  return Object.keys(record);
+}
 const registeredMigrations = new Map();
 const runMicrotask = typeof queueMicrotask === "function" ? queueMicrotask : task => {
   Promise.resolve().then(task);
@@ -54,17 +77,83 @@ const memoryStore = new Map();
 const memoryListeners = new Map();
 const webScopeListeners = 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 webScopeKeyIndex = new Map([[_Storage.StorageScope.Disk, new Set()], [_Storage.StorageScope.Secure, new Set()]]);
+const hydratedWebScopeKeyIndex = new Set();
 const pendingSecureWrites = new Map();
 let secureFlushScheduled = false;
 const SECURE_WEB_PREFIX = "__secure_";
 const BIOMETRIC_WEB_PREFIX = "__bio_";
 let hasWarnedAboutWebBiometricFallback = false;
+let hasWebStorageEventSubscription = false;
+let metricsObserver;
+const metricsCounters = new Map();
+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) {
+  const start = Date.now();
+  try {
+    return fn();
+  } finally {
+    recordMetric(operation, scope, Date.now() - start, keysCount);
+  }
+}
+function createLocalStorageWebSecureBackend() {
+  return {
+    getItem: key => globalThis.localStorage?.getItem(key) ?? null,
+    setItem: (key, value) => globalThis.localStorage?.setItem(key, value),
+    removeItem: key => globalThis.localStorage?.removeItem(key),
+    clear: () => globalThis.localStorage?.clear(),
+    getAllKeys: () => {
+      const storage = globalThis.localStorage;
+      if (!storage) return [];
+      const keys = [];
+      for (let index = 0; index < storage.length; index += 1) {
+        const key = storage.key(index);
+        if (key) {
+          keys.push(key);
+        }
+      }
+      return keys;
+    }
+  };
+}
+let webSecureStorageBackend = createLocalStorageWebSecureBackend();
 function getBrowserStorage(scope) {
   if (scope === _Storage.StorageScope.Disk) {
     return globalThis.localStorage;
   }
   if (scope === _Storage.StorageScope.Secure) {
-    return globalThis.localStorage;
+    if (!webSecureStorageBackend) {
+      return undefined;
+    }
+    return {
+      setItem: (key, value) => webSecureStorageBackend?.setItem(key, value),
+      getItem: key => webSecureStorageBackend?.getItem(key) ?? null,
+      removeItem: key => webSecureStorageBackend?.removeItem(key),
+      clear: () => webSecureStorageBackend?.clear(),
+      key: index => webSecureStorageBackend?.getAllKeys()[index] ?? null,
+      get length() {
+        return webSecureStorageBackend?.getAllKeys().length ?? 0;
+      }
+    };
   }
   return undefined;
 }
@@ -80,6 +169,99 @@ function toBiometricStorageKey(key) {
 function fromBiometricStorageKey(key) {
   return key.slice(BIOMETRIC_WEB_PREFIX.length);
 }
+function getWebScopeKeyIndex(scope) {
+  return webScopeKeyIndex.get(scope);
+}
+function hydrateWebScopeKeyIndex(scope) {
+  if (hydratedWebScopeKeyIndex.has(scope)) {
+    return;
+  }
+  const storage = getBrowserStorage(scope);
+  const keyIndex = getWebScopeKeyIndex(scope);
+  keyIndex.clear();
+  if (storage) {
+    for (let index = 0; index < storage.length; index += 1) {
+      const key = storage.key(index);
+      if (!key) {
+        continue;
+      }
+      if (scope === _Storage.StorageScope.Disk) {
+        if (!key.startsWith(SECURE_WEB_PREFIX) && !key.startsWith(BIOMETRIC_WEB_PREFIX)) {
+          keyIndex.add(key);
+        }
+        continue;
+      }
+      if (key.startsWith(SECURE_WEB_PREFIX)) {
+        keyIndex.add(fromSecureStorageKey(key));
+        continue;
+      }
+      if (key.startsWith(BIOMETRIC_WEB_PREFIX)) {
+        keyIndex.add(fromBiometricStorageKey(key));
+      }
+    }
+  }
+  hydratedWebScopeKeyIndex.add(scope);
+}
+function ensureWebScopeKeyIndex(scope) {
+  hydrateWebScopeKeyIndex(scope);
+  return getWebScopeKeyIndex(scope);
+}
+function handleWebStorageEvent(event) {
+  const key = event.key;
+  if (key === null) {
+    clearScopeRawCache(_Storage.StorageScope.Disk);
+    clearScopeRawCache(_Storage.StorageScope.Secure);
+    ensureWebScopeKeyIndex(_Storage.StorageScope.Disk).clear();
+    ensureWebScopeKeyIndex(_Storage.StorageScope.Secure).clear();
+    notifyAllListeners(getScopedListeners(_Storage.StorageScope.Disk));
+    notifyAllListeners(getScopedListeners(_Storage.StorageScope.Secure));
+    return;
+  }
+  if (key.startsWith(SECURE_WEB_PREFIX)) {
+    const plainKey = fromSecureStorageKey(key);
+    if (event.newValue === null) {
+      ensureWebScopeKeyIndex(_Storage.StorageScope.Secure).delete(plainKey);
+      cacheRawValue(_Storage.StorageScope.Secure, plainKey, undefined);
+    } else {
+      ensureWebScopeKeyIndex(_Storage.StorageScope.Secure).add(plainKey);
+      cacheRawValue(_Storage.StorageScope.Secure, plainKey, event.newValue);
+    }
+    notifyKeyListeners(getScopedListeners(_Storage.StorageScope.Secure), plainKey);
+    return;
+  }
+  if (key.startsWith(BIOMETRIC_WEB_PREFIX)) {
+    const plainKey = fromBiometricStorageKey(key);
+    if (event.newValue === null) {
+      if (getBrowserStorage(_Storage.StorageScope.Secure)?.getItem(toSecureStorageKey(plainKey)) === null) {
+        ensureWebScopeKeyIndex(_Storage.StorageScope.Secure).delete(plainKey);
+      }
+      cacheRawValue(_Storage.StorageScope.Secure, plainKey, undefined);
+    } else {
+      ensureWebScopeKeyIndex(_Storage.StorageScope.Secure).add(plainKey);
+      cacheRawValue(_Storage.StorageScope.Secure, plainKey, event.newValue);
+    }
+    notifyKeyListeners(getScopedListeners(_Storage.StorageScope.Secure), plainKey);
+    return;
+  }
+  if (event.newValue === null) {
+    ensureWebScopeKeyIndex(_Storage.StorageScope.Disk).delete(key);
+    cacheRawValue(_Storage.StorageScope.Disk, key, undefined);
+  } else {
+    ensureWebScopeKeyIndex(_Storage.StorageScope.Disk).add(key);
+    cacheRawValue(_Storage.StorageScope.Disk, key, event.newValue);
+  }
+  notifyKeyListeners(getScopedListeners(_Storage.StorageScope.Disk), key);
+}
+function ensureWebStorageEventSubscription() {
+  if (hasWebStorageEventSubscription) {
+    return;
+  }
+  if (typeof window === "undefined" || typeof window.addEventListener !== "function") {
+    return;
+  }
+  window.addEventListener("storage", handleWebStorageEvent);
+  hasWebStorageEventSubscription = true;
+}
 function getScopedListeners(scope) {
   return webScopeListeners.get(scope);
 }
@@ -140,32 +322,46 @@ function flushSecureWrites() {
   }
   const writes = Array.from(pendingSecureWrites.values());
   pendingSecureWrites.clear();
-  const keysToSet = [];
-  const valuesToSet = [];
+  const groupedSetWrites = new Map();
   const keysToRemove = [];
   writes.forEach(({
     key,
-    value
+    value,
+    accessControl
   }) => {
     if (value === undefined) {
       keysToRemove.push(key);
     } else {
-      keysToSet.push(key);
-      valuesToSet.push(value);
+      const resolvedAccessControl = accessControl ?? _Storage.AccessControl.WhenUnlocked;
+      const existingGroup = groupedSetWrites.get(resolvedAccessControl);
+      const group = existingGroup ?? {
+        keys: [],
+        values: []
+      };
+      group.keys.push(key);
+      group.values.push(value);
+      if (!existingGroup) {
+        groupedSetWrites.set(resolvedAccessControl, group);
+      }
     }
   });
-  if (keysToSet.length > 0) {
-    WebStorage.setBatch(keysToSet, valuesToSet, _Storage.StorageScope.Secure);
-  }
+  groupedSetWrites.forEach((group, accessControl) => {
+    WebStorage.setSecureAccessControl(accessControl);
+    WebStorage.setBatch(group.keys, group.values, _Storage.StorageScope.Secure);
+  });
   if (keysToRemove.length > 0) {
     WebStorage.removeBatch(keysToRemove, _Storage.StorageScope.Secure);
   }
 }
-function scheduleSecureWrite(key, value) {
-  pendingSecureWrites.set(key, {
+function scheduleSecureWrite(key, value, accessControl) {
+  const pendingWrite = {
     key,
     value
-  });
+  };
+  if (accessControl !== undefined) {
+    pendingWrite.accessControl = accessControl;
+  }
+  pendingSecureWrites.set(key, pendingWrite);
   if (secureFlushScheduled) {
     return;
   }
@@ -184,6 +380,7 @@ const WebStorage = {
     const storageKey = scope === _Storage.StorageScope.Secure ? toSecureStorageKey(key) : key;
     storage.setItem(storageKey, value);
     if (scope === _Storage.StorageScope.Disk || scope === _Storage.StorageScope.Secure) {
+      ensureWebScopeKeyIndex(scope).add(key);
       notifyKeyListeners(getScopedListeners(scope), key);
     }
   },
@@ -204,6 +401,7 @@ const WebStorage = {
       storage.removeItem(key);
     }
     if (scope === _Storage.StorageScope.Disk || scope === _Storage.StorageScope.Secure) {
+      ensureWebScopeKeyIndex(scope).delete(key);
       notifyKeyListeners(getScopedListeners(scope), key);
     }
   },
@@ -234,6 +432,7 @@ const WebStorage = {
       storage.clear();
     }
     if (scope === _Storage.StorageScope.Disk || scope === _Storage.StorageScope.Secure) {
+      ensureWebScopeKeyIndex(scope).clear();
       notifyAllListeners(getScopedListeners(scope));
     }
   },
@@ -243,10 +442,16 @@ const WebStorage = {
       return;
     }
     keys.forEach((key, index) => {
+      const value = values[index];
+      if (value === undefined) {
+        return;
+      }
       const storageKey = scope === _Storage.StorageScope.Secure ? toSecureStorageKey(key) : key;
-      storage.setItem(storageKey, values[index]);
+      storage.setItem(storageKey, value);
     });
     if (scope === _Storage.StorageScope.Disk || scope === _Storage.StorageScope.Secure) {
+      const keyIndex = ensureWebScopeKeyIndex(scope);
+      keys.forEach(key => keyIndex.add(key));
       const listeners = getScopedListeners(scope);
       keys.forEach(key => notifyKeyListeners(listeners, key));
     }
@@ -259,9 +464,37 @@ const WebStorage = {
     });
   },
   removeBatch: (keys, scope) => {
-    keys.forEach(key => {
-      WebStorage.remove(key, scope);
-    });
+    const storage = getBrowserStorage(scope);
+    if (!storage) {
+      return;
+    }
+    if (scope === _Storage.StorageScope.Secure) {
+      keys.forEach(key => {
+        storage.removeItem(toSecureStorageKey(key));
+        storage.removeItem(toBiometricStorageKey(key));
+      });
+    } else {
+      keys.forEach(key => {
+        storage.removeItem(key);
+      });
+    }
+    if (scope === _Storage.StorageScope.Disk || scope === _Storage.StorageScope.Secure) {
+      const keyIndex = ensureWebScopeKeyIndex(scope);
+      keys.forEach(key => keyIndex.delete(key));
+      const listeners = getScopedListeners(scope);
+      keys.forEach(key => notifyKeyListeners(listeners, key));
+    }
+  },
+  removeByPrefix: (prefix, scope) => {
+    if (scope !== _Storage.StorageScope.Disk && scope !== _Storage.StorageScope.Secure) {
+      return;
+    }
+    const keyIndex = ensureWebScopeKeyIndex(scope);
+    const keys = Array.from(keyIndex).filter(key => key.startsWith(prefix));
+    if (keys.length === 0) {
+      return;
+    }
+    WebStorage.removeBatch(keys, scope);
   },
   addOnChange: (_scope, _callback) => {
     return () => {};
@@ -274,54 +507,54 @@ const WebStorage = {
     return storage?.getItem(key) !== null;
   },
   getAllKeys: scope => {
-    const storage = getBrowserStorage(scope);
-    if (!storage) return [];
-    const keys = new Set();
-    for (let i = 0; i < storage.length; i++) {
-      const k = storage.key(i);
-      if (!k) {
-        continue;
-      }
-      if (scope === _Storage.StorageScope.Secure) {
-        if (k.startsWith(SECURE_WEB_PREFIX)) {
-          keys.add(fromSecureStorageKey(k));
-        } else if (k.startsWith(BIOMETRIC_WEB_PREFIX)) {
-          keys.add(fromBiometricStorageKey(k));
-        }
-        continue;
-      }
-      if (k.startsWith(SECURE_WEB_PREFIX) || k.startsWith(BIOMETRIC_WEB_PREFIX)) {
-        continue;
-      }
-      keys.add(k);
+    if (scope !== _Storage.StorageScope.Disk && scope !== _Storage.StorageScope.Secure) {
+      return [];
+    }
+    return Array.from(ensureWebScopeKeyIndex(scope));
+  },
+  getKeysByPrefix: (prefix, scope) => {
+    if (scope !== _Storage.StorageScope.Disk && scope !== _Storage.StorageScope.Secure) {
+      return [];
     }
-    return Array.from(keys);
+    return Array.from(ensureWebScopeKeyIndex(scope)).filter(key => key.startsWith(prefix));
   },
   size: scope => {
-    return WebStorage.getAllKeys(scope).length;
+    if (scope === _Storage.StorageScope.Disk || scope === _Storage.StorageScope.Secure) {
+      return ensureWebScopeKeyIndex(scope).size;
+    }
+    return 0;
   },
   setSecureAccessControl: () => {},
+  setSecureWritesAsync: _enabled => {},
   setKeychainAccessGroup: () => {},
   setSecureBiometric: (key, value) => {
+    WebStorage.setSecureBiometricWithLevel(key, value, _Storage.BiometricLevel.BiometryOnly);
+  },
+  setSecureBiometricWithLevel: (key, value, _level) => {
     if (typeof __DEV__ !== "undefined" && __DEV__ && !hasWarnedAboutWebBiometricFallback) {
       hasWarnedAboutWebBiometricFallback = true;
       console.warn("[NitroStorage] Biometric storage is not supported on web. Using localStorage.");
     }
-    globalThis.localStorage?.setItem(toBiometricStorageKey(key), value);
+    getBrowserStorage(_Storage.StorageScope.Secure)?.setItem(toBiometricStorageKey(key), value);
+    ensureWebScopeKeyIndex(_Storage.StorageScope.Secure).add(key);
     notifyKeyListeners(getScopedListeners(_Storage.StorageScope.Secure), key);
   },
   getSecureBiometric: key => {
-    return globalThis.localStorage?.getItem(toBiometricStorageKey(key)) ?? undefined;
+    return getBrowserStorage(_Storage.StorageScope.Secure)?.getItem(toBiometricStorageKey(key)) ?? undefined;
   },
   deleteSecureBiometric: key => {
-    globalThis.localStorage?.removeItem(toBiometricStorageKey(key));
+    const storage = getBrowserStorage(_Storage.StorageScope.Secure);
+    storage?.removeItem(toBiometricStorageKey(key));
+    if (storage?.getItem(toSecureStorageKey(key)) === null) {
+      ensureWebScopeKeyIndex(_Storage.StorageScope.Secure).delete(key);
+    }
     notifyKeyListeners(getScopedListeners(_Storage.StorageScope.Secure), key);
   },
   hasSecureBiometric: key => {
-    return globalThis.localStorage?.getItem(toBiometricStorageKey(key)) !== null;
+    return getBrowserStorage(_Storage.StorageScope.Secure)?.getItem(toBiometricStorageKey(key)) !== null;
   },
   clearSecureBiometric: () => {
-    const storage = globalThis.localStorage;
+    const storage = getBrowserStorage(_Storage.StorageScope.Secure);
     if (!storage) return;
     const keysToNotify = [];
     const toRemove = [];
@@ -333,6 +566,12 @@ const WebStorage = {
       }
     }
     toRemove.forEach(k => storage.removeItem(k));
+    const keyIndex = ensureWebScopeKeyIndex(_Storage.StorageScope.Secure);
+    keysToNotify.forEach(key => {
+      if (storage.getItem(toSecureStorageKey(key)) === null) {
+        keyIndex.delete(key);
+      }
+    });
     const listeners = getScopedListeners(_Storage.StorageScope.Secure);
     keysToNotify.forEach(key => notifyKeyListeners(listeners, key));
   }
@@ -389,90 +628,173 @@ function writeMigrationVersion(scope, version) {
 }
 const storage = exports.storage = {
   clear: scope => {
-    if (scope === _Storage.StorageScope.Memory) {
-      memoryStore.clear();
-      notifyAllListeners(memoryListeners);
-      return;
-    }
-    if (scope === _Storage.StorageScope.Secure) {
-      flushSecureWrites();
-      pendingSecureWrites.clear();
-    }
-    clearScopeRawCache(scope);
-    WebStorage.clear(scope);
-    if (scope === _Storage.StorageScope.Secure) {
-      WebStorage.clearSecureBiometric();
-    }
+    measureOperation("storage:clear", scope, () => {
+      if (scope === _Storage.StorageScope.Memory) {
+        memoryStore.clear();
+        notifyAllListeners(memoryListeners);
+        return;
+      }
+      if (scope === _Storage.StorageScope.Secure) {
+        flushSecureWrites();
+        pendingSecureWrites.clear();
+      }
+      clearScopeRawCache(scope);
+      WebStorage.clear(scope);
+    });
   },
   clearAll: () => {
-    storage.clear(_Storage.StorageScope.Memory);
-    storage.clear(_Storage.StorageScope.Disk);
-    storage.clear(_Storage.StorageScope.Secure);
+    measureOperation("storage:clearAll", _Storage.StorageScope.Memory, () => {
+      storage.clear(_Storage.StorageScope.Memory);
+      storage.clear(_Storage.StorageScope.Disk);
+      storage.clear(_Storage.StorageScope.Secure);
+    }, 3);
   },
   clearNamespace: (namespace, scope) => {
-    (0, _internal.assertValidScope)(scope);
-    if (scope === _Storage.StorageScope.Memory) {
-      for (const key of memoryStore.keys()) {
-        if ((0, _internal.isNamespaced)(key, namespace)) {
-          memoryStore.delete(key);
+    measureOperation("storage:clearNamespace", scope, () => {
+      (0, _internal.assertValidScope)(scope);
+      if (scope === _Storage.StorageScope.Memory) {
+        for (const key of memoryStore.keys()) {
+          if ((0, _internal.isNamespaced)(key, namespace)) {
+            memoryStore.delete(key);
+          }
         }
+        notifyAllListeners(memoryListeners);
+        return;
       }
-      notifyAllListeners(memoryListeners);
-      return;
-    }
-    if (scope === _Storage.StorageScope.Secure) {
-      flushSecureWrites();
-    }
-    const keys = WebStorage.getAllKeys(scope);
-    const namespacedKeys = keys.filter(k => (0, _internal.isNamespaced)(k, namespace));
-    if (namespacedKeys.length > 0) {
-      WebStorage.removeBatch(namespacedKeys, scope);
-      namespacedKeys.forEach(k => cacheRawValue(scope, k, undefined));
+      const keyPrefix = (0, _internal.prefixKey)(namespace, "");
       if (scope === _Storage.StorageScope.Secure) {
-        namespacedKeys.forEach(k => clearPendingSecureWrite(k));
+        flushSecureWrites();
       }
-    }
+      clearScopeRawCache(scope);
+      WebStorage.removeByPrefix(keyPrefix, scope);
+    });
   },
   clearBiometric: () => {
-    WebStorage.clearSecureBiometric();
+    measureOperation("storage:clearBiometric", _Storage.StorageScope.Secure, () => {
+      WebStorage.clearSecureBiometric();
+    });
   },
   has: (key, scope) => {
-    (0, _internal.assertValidScope)(scope);
-    if (scope === _Storage.StorageScope.Memory) return memoryStore.has(key);
-    return WebStorage.has(key, scope);
+    return measureOperation("storage:has", scope, () => {
+      (0, _internal.assertValidScope)(scope);
+      if (scope === _Storage.StorageScope.Memory) return memoryStore.has(key);
+      return WebStorage.has(key, scope);
+    });
   },
   getAllKeys: scope => {
-    (0, _internal.assertValidScope)(scope);
-    if (scope === _Storage.StorageScope.Memory) return Array.from(memoryStore.keys());
-    return WebStorage.getAllKeys(scope);
+    return measureOperation("storage:getAllKeys", scope, () => {
+      (0, _internal.assertValidScope)(scope);
+      if (scope === _Storage.StorageScope.Memory) return Array.from(memoryStore.keys());
+      return WebStorage.getAllKeys(scope);
+    });
+  },
+  getKeysByPrefix: (prefix, scope) => {
+    return measureOperation("storage:getKeysByPrefix", scope, () => {
+      (0, _internal.assertValidScope)(scope);
+      if (scope === _Storage.StorageScope.Memory) {
+        return Array.from(memoryStore.keys()).filter(key => key.startsWith(prefix));
+      }
+      return WebStorage.getKeysByPrefix(prefix, scope);
+    });
+  },
+  getByPrefix: (prefix, scope) => {
+    return measureOperation("storage:getByPrefix", scope, () => {
+      const result = {};
+      const keys = storage.getKeysByPrefix(prefix, scope);
+      if (keys.length === 0) {
+        return result;
+      }
+      if (scope === _Storage.StorageScope.Memory) {
+        keys.forEach(key => {
+          const value = memoryStore.get(key);
+          if (typeof value === "string") {
+            result[key] = value;
+          }
+        });
+        return result;
+      }
+      const values = WebStorage.getBatch(keys, scope);
+      keys.forEach((key, index) => {
+        const value = values[index];
+        if (value !== undefined) {
+          result[key] = value;
+        }
+      });
+      return result;
+    });
   },
   getAll: scope => {
-    (0, _internal.assertValidScope)(scope);
-    const result = {};
-    if (scope === _Storage.StorageScope.Memory) {
-      memoryStore.forEach((value, key) => {
-        if (typeof value === "string") result[key] = value;
+    return measureOperation("storage:getAll", scope, () => {
+      (0, _internal.assertValidScope)(scope);
+      const result = {};
+      if (scope === _Storage.StorageScope.Memory) {
+        memoryStore.forEach((value, key) => {
+          if (typeof value === "string") result[key] = value;
+        });
+        return result;
+      }
+      const keys = WebStorage.getAllKeys(scope);
+      keys.forEach(key => {
+        const val = WebStorage.get(key, scope);
+        if (val !== undefined) result[key] = val;
       });
       return result;
-    }
-    const keys = WebStorage.getAllKeys(scope);
-    keys.forEach(key => {
-      const val = WebStorage.get(key, scope);
-      if (val !== undefined) result[key] = val;
     });
-    return result;
   },
   size: scope => {
-    (0, _internal.assertValidScope)(scope);
-    if (scope === _Storage.StorageScope.Memory) return memoryStore.size;
-    return WebStorage.size(scope);
+    return measureOperation("storage:size", scope, () => {
+      (0, _internal.assertValidScope)(scope);
+      if (scope === _Storage.StorageScope.Memory) return memoryStore.size;
+      return WebStorage.size(scope);
+    });
+  },
+  setAccessControl: _level => {
+    recordMetric("storage:setAccessControl", _Storage.StorageScope.Secure, 0);
+  },
+  setSecureWritesAsync: _enabled => {
+    recordMetric("storage:setSecureWritesAsync", _Storage.StorageScope.Secure, 0);
   },
-  setAccessControl: _level => {},
-  setKeychainAccessGroup: _group => {}
+  flushSecureWrites: () => {
+    measureOperation("storage:flushSecureWrites", _Storage.StorageScope.Secure, () => {
+      flushSecureWrites();
+    });
+  },
+  setKeychainAccessGroup: _group => {
+    recordMetric("storage:setKeychainAccessGroup", _Storage.StorageScope.Secure, 0);
+  },
+  setMetricsObserver: observer => {
+    metricsObserver = 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;
+  },
+  resetMetrics: () => {
+    metricsCounters.clear();
+  }
 };
+function setWebSecureStorageBackend(backend) {
+  webSecureStorageBackend = backend ?? createLocalStorageWebSecureBackend();
+  hydratedWebScopeKeyIndex.delete(_Storage.StorageScope.Secure);
+  clearScopeRawCache(_Storage.StorageScope.Secure);
+}
+function getWebSecureStorageBackend() {
+  return webSecureStorageBackend;
+}
 function canUseRawBatchPath(item) {
   return item._hasExpiration === false && item._hasValidation === false && item._isBiometric !== true && item._secureAccessControl === undefined;
 }
+function canUseSecureRawBatchPath(item) {
+  return item._hasExpiration === false && item._hasValidation === false && item._isBiometric !== true;
+}
 function defaultSerialize(value) {
   return (0, _internal.serializeWithPrimitiveFastPath)(value);
 }
@@ -484,7 +806,8 @@ function createStorageItem(config) {
   const serialize = config.serialize ?? defaultSerialize;
   const deserialize = config.deserialize ?? defaultDeserialize;
   const isMemory = config.scope === _Storage.StorageScope.Memory;
-  const isBiometric = config.biometric === true && config.scope === _Storage.StorageScope.Secure;
+  const resolvedBiometricLevel = config.scope === _Storage.StorageScope.Secure ? config.biometricLevel ?? (config.biometric === true ? _Storage.BiometricLevel.BiometryOnly : _Storage.BiometricLevel.None) : _Storage.BiometricLevel.None;
+  const isBiometric = resolvedBiometricLevel !== _Storage.BiometricLevel.None;
   const secureAccessControl = config.accessControl;
   const validate = config.validate;
   const onValidationError = config.onValidationError;
@@ -493,7 +816,8 @@ function createStorageItem(config) {
   const expirationTtlMs = expiration?.ttlMs;
   const memoryExpiration = expiration && isMemory ? new Map() : null;
   const readCache = !isMemory && config.readCache === true;
-  const coalesceSecureWrites = config.scope === _Storage.StorageScope.Secure && config.coalesceSecureWrites === true && !isBiometric && secureAccessControl === undefined;
+  const coalesceSecureWrites = config.scope === _Storage.StorageScope.Secure && config.coalesceSecureWrites === true && !isBiometric;
+  const defaultValue = config.defaultValue;
   const nonMemoryScope = config.scope === _Storage.StorageScope.Disk ? _Storage.StorageScope.Disk : config.scope === _Storage.StorageScope.Secure ? _Storage.StorageScope.Secure : null;
   if (expiration && expiration.ttlMs <= 0) {
     throw new Error("expiration.ttlMs must be greater than 0.");
@@ -503,10 +827,12 @@ function createStorageItem(config) {
   let lastRaw = undefined;
   let lastValue;
   let hasLastValue = false;
+  let lastExpiresAt = undefined;
   const invalidateParsedCache = () => {
     lastRaw = undefined;
     lastValue = undefined;
     hasLastValue = false;
+    lastExpiresAt = undefined;
   };
   const ensureSubscription = () => {
     if (unsubscribe) {
@@ -520,6 +846,7 @@ function createStorageItem(config) {
       unsubscribe = addKeyListener(memoryListeners, storageKey, listener);
       return;
     }
+    ensureWebStorageEventSubscription();
     unsubscribe = addKeyListener(getScopedListeners(nonMemoryScope), storageKey, listener);
   };
   const readStoredRaw = () => {
@@ -553,12 +880,12 @@ function createStorageItem(config) {
   };
   const writeStoredRaw = rawValue => {
     if (isBiometric) {
-      WebStorage.setSecureBiometric(storageKey, rawValue);
+      WebStorage.setSecureBiometricWithLevel(storageKey, rawValue, resolvedBiometricLevel);
       return;
     }
     cacheRawValue(nonMemoryScope, storageKey, rawValue);
     if (coalesceSecureWrites) {
-      scheduleSecureWrite(storageKey, rawValue);
+      scheduleSecureWrite(storageKey, rawValue, secureAccessControl ?? _Storage.AccessControl.WhenUnlocked);
       return;
     }
     if (nonMemoryScope === _Storage.StorageScope.Secure) {
@@ -573,7 +900,7 @@ function createStorageItem(config) {
     }
     cacheRawValue(nonMemoryScope, storageKey, undefined);
     if (coalesceSecureWrites) {
-      scheduleSecureWrite(storageKey, undefined);
+      scheduleSecureWrite(storageKey, undefined, secureAccessControl ?? _Storage.AccessControl.WhenUnlocked);
       return;
     }
     if (nonMemoryScope === _Storage.StorageScope.Secure) {
@@ -606,7 +933,7 @@ function createStorageItem(config) {
     if (onValidationError) {
       return onValidationError(invalidValue);
     }
-    return config.defaultValue;
+    return defaultValue;
   };
   const ensureValidatedValue = (candidate, hadStoredValue) => {
     if (!validate || validate(candidate)) {
@@ -614,40 +941,62 @@ function createStorageItem(config) {
     }
     const resolved = resolveInvalidValue(candidate);
     if (validate && !validate(resolved)) {
-      return config.defaultValue;
+      return defaultValue;
     }
     if (hadStoredValue) {
       writeValueWithoutValidation(resolved);
     }
     return resolved;
   };
-  const get = () => {
+  const getInternal = () => {
     const raw = readStoredRaw();
-    const canUseCachedValue = !expiration && !memoryExpiration;
-    if (canUseCachedValue && raw === lastRaw && hasLastValue) {
-      return lastValue;
+    if (!memoryExpiration && raw === lastRaw && hasLastValue) {
+      if (!expiration || lastExpiresAt === null) {
+        return lastValue;
+      }
+      if (typeof lastExpiresAt === "number") {
+        if (lastExpiresAt > Date.now()) {
+          return lastValue;
+        }
+        removeStoredRaw();
+        invalidateParsedCache();
+        onExpired?.(storageKey);
+        lastValue = ensureValidatedValue(defaultValue, false);
+        hasLastValue = true;
+        return lastValue;
+      }
     }
     lastRaw = raw;
     if (raw === undefined) {
-      lastValue = ensureValidatedValue(config.defaultValue, false);
+      lastExpiresAt = undefined;
+      lastValue = ensureValidatedValue(defaultValue, false);
       hasLastValue = true;
       return lastValue;
     }
     if (isMemory) {
+      lastExpiresAt = undefined;
       lastValue = ensureValidatedValue(raw, true);
       hasLastValue = true;
       return lastValue;
     }
+    if (typeof raw !== "string") {
+      lastExpiresAt = undefined;
+      lastValue = ensureValidatedValue(defaultValue, false);
+      hasLastValue = true;
+      return lastValue;
+    }
     let deserializableRaw = raw;
     if (expiration) {
+      let envelopeExpiresAt = null;
       try {
         const parsed = JSON.parse(raw);
         if ((0, _internal.isStoredEnvelope)(parsed)) {
+          envelopeExpiresAt = parsed.expiresAt;
           if (parsed.expiresAt <= Date.now()) {
             removeStoredRaw();
             invalidateParsedCache();
             onExpired?.(storageKey);
-            lastValue = ensureValidatedValue(config.defaultValue, false);
+            lastValue = ensureValidatedValue(defaultValue, false);
             hasLastValue = true;
             return lastValue;
           }
@@ -656,37 +1005,60 @@ function createStorageItem(config) {
       } catch {
         // Keep backward compatibility with legacy raw values.
       }
+      lastExpiresAt = envelopeExpiresAt;
+    } else {
+      lastExpiresAt = undefined;
     }
     lastValue = ensureValidatedValue(deserialize(deserializableRaw), true);
     hasLastValue = true;
     return lastValue;
   };
+  const getCurrentVersion = () => {
+    const raw = readStoredRaw();
+    return (0, _internal.toVersionToken)(raw);
+  };
+  const get = () => measureOperation("item:get", config.scope, () => getInternal());
+  const getWithVersion = () => measureOperation("item:getWithVersion", config.scope, () => ({
+    value: getInternal(),
+    version: getCurrentVersion()
+  }));
   const set = valueOrFn => {
-    const currentValue = get();
-    const newValue = typeof valueOrFn === "function" ? valueOrFn(currentValue) : valueOrFn;
-    invalidateParsedCache();
-    if (validate && !validate(newValue)) {
-      throw new Error(`Validation failed for key "${storageKey}" in scope "${_Storage.StorageScope[config.scope]}".`);
-    }
-    writeValueWithoutValidation(newValue);
+    measureOperation("item:set", config.scope, () => {
+      const newValue = isUpdater(valueOrFn) ? valueOrFn(getInternal()) : valueOrFn;
+      invalidateParsedCache();
+      if (validate && !validate(newValue)) {
+        throw new Error(`Validation failed for key "${storageKey}" in scope "${_Storage.StorageScope[config.scope]}".`);
+      }
+      writeValueWithoutValidation(newValue);
+    });
   };
+  const setIfVersion = (version, valueOrFn) => measureOperation("item:setIfVersion", config.scope, () => {
+    const currentVersion = getCurrentVersion();
+    if (currentVersion !== version) {
+      return false;
+    }
+    set(valueOrFn);
+    return true;
+  });
   const deleteItem = () => {
-    invalidateParsedCache();
-    if (isMemory) {
-      if (memoryExpiration) {
-        memoryExpiration.delete(storageKey);
+    measureOperation("item:delete", config.scope, () => {
+      invalidateParsedCache();
+      if (isMemory) {
+        if (memoryExpiration) {
+          memoryExpiration.delete(storageKey);
+        }
+        memoryStore.delete(storageKey);
+        notifyKeyListeners(memoryListeners, storageKey);
+        return;
       }
-      memoryStore.delete(storageKey);
-      notifyKeyListeners(memoryListeners, storageKey);
-      return;
-    }
-    removeStoredRaw();
+      removeStoredRaw();
+    });
   };
-  const hasItem = () => {
+  const hasItem = () => measureOperation("item:has", config.scope, () => {
     if (isMemory) return memoryStore.has(storageKey);
     if (isBiometric) return WebStorage.hasSecureBiometric(storageKey);
     return WebStorage.has(storageKey, config.scope);
-  };
+  });
   const subscribe = callback => {
     ensureSubscription();
     listeners.add(callback);
@@ -700,7 +1072,9 @@ function createStorageItem(config) {
   };
   const storageItem = {
     get,
+    getWithVersion,
     set,
+    setIfVersion,
     delete: deleteItem,
     has: hasItem,
     subscribe,
@@ -714,123 +1088,150 @@ function createStorageItem(config) {
     _hasExpiration: expiration !== undefined,
     _readCacheEnabled: readCache,
     _isBiometric: isBiometric,
-    _secureAccessControl: secureAccessControl,
+    _defaultValue: defaultValue,
+    ...(secureAccessControl !== undefined ? {
+      _secureAccessControl: secureAccessControl
+    } : {}),
     scope: config.scope,
     key: storageKey
   };
   return storageItem;
 }
-function useStorage(item) {
-  const value = (0, _react.useSyncExternalStore)(item.subscribe, item.get, item.get);
-  return [value, item.set];
-}
-function useStorageSelector(item, selector, isEqual = Object.is) {
-  const selectedRef = (0, _react.useRef)({
-    hasValue: false
-  });
-  const getSelectedSnapshot = () => {
-    const nextSelected = selector(item.get());
-    const current = selectedRef.current;
-    if (current.hasValue && isEqual(current.value, nextSelected)) {
-      return current.value;
-    }
-    selectedRef.current = {
-      hasValue: true,
-      value: nextSelected
-    };
-    return nextSelected;
-  };
-  const selectedValue = (0, _react.useSyncExternalStore)(item.subscribe, getSelectedSnapshot, getSelectedSnapshot);
-  return [selectedValue, item.set];
-}
-function useSetStorage(item) {
-  return item.set;
-}
 function getBatch(items, scope) {
-  (0, _internal.assertBatchScope)(items, scope);
-  if (scope === _Storage.StorageScope.Memory) {
-    return items.map(item => item.get());
-  }
-  const useRawBatchPath = items.every(item => canUseRawBatchPath(item));
-  if (!useRawBatchPath) {
-    return items.map(item => item.get());
-  }
-  const useBatchCache = items.every(item => item._readCacheEnabled === true);
-  const rawValues = new Array(items.length);
-  const keysToFetch = [];
-  const keyIndexes = [];
-  items.forEach((item, index) => {
-    if (scope === _Storage.StorageScope.Secure) {
-      if (hasPendingSecureWrite(item.key)) {
-        rawValues[index] = readPendingSecureWrite(item.key);
-        return;
-      }
+  return measureOperation("batch:get", scope, () => {
+    (0, _internal.assertBatchScope)(items, scope);
+    if (scope === _Storage.StorageScope.Memory) {
+      return items.map(item => item.get());
     }
-    if (useBatchCache) {
-      if (hasCachedRawValue(scope, item.key)) {
-        rawValues[index] = readCachedRawValue(scope, item.key);
-        return;
-      }
+    const useRawBatchPath = items.every(item => scope === _Storage.StorageScope.Secure ? canUseSecureRawBatchPath(item) : canUseRawBatchPath(item));
+    if (!useRawBatchPath) {
+      return items.map(item => item.get());
     }
-    keysToFetch.push(item.key);
-    keyIndexes.push(index);
-  });
-  if (keysToFetch.length > 0) {
-    const fetchedValues = WebStorage.getBatch(keysToFetch, scope);
-    fetchedValues.forEach((value, index) => {
-      const key = keysToFetch[index];
-      const targetIndex = keyIndexes[index];
-      rawValues[targetIndex] = value;
-      cacheRawValue(scope, key, value);
+    const rawValues = new Array(items.length);
+    const keysToFetch = [];
+    const keyIndexes = [];
+    items.forEach((item, index) => {
+      if (scope === _Storage.StorageScope.Secure) {
+        if (hasPendingSecureWrite(item.key)) {
+          rawValues[index] = readPendingSecureWrite(item.key);
+          return;
+        }
+      }
+      if (item._readCacheEnabled === true) {
+        if (hasCachedRawValue(scope, item.key)) {
+          rawValues[index] = readCachedRawValue(scope, item.key);
+          return;
+        }
+      }
+      keysToFetch.push(item.key);
+      keyIndexes.push(index);
     });
-  }
-  return items.map((item, index) => {
-    const raw = rawValues[index];
-    if (raw === undefined) {
-      return item.get();
+    if (keysToFetch.length > 0) {
+      const fetchedValues = WebStorage.getBatch(keysToFetch, scope);
+      fetchedValues.forEach((value, index) => {
+        const key = keysToFetch[index];
+        const targetIndex = keyIndexes[index];
+        if (key === undefined || targetIndex === undefined) {
+          return;
+        }
+        rawValues[targetIndex] = value;
+        cacheRawValue(scope, key, value);
+      });
     }
-    return item.deserialize(raw);
-  });
+    return items.map((item, index) => {
+      const raw = rawValues[index];
+      if (raw === undefined) {
+        return asInternal(item)._defaultValue;
+      }
+      return item.deserialize(raw);
+    });
+  }, items.length);
 }
 function setBatch(items, scope) {
-  (0, _internal.assertBatchScope)(items.map(batchEntry => batchEntry.item), scope);
-  if (scope === _Storage.StorageScope.Memory) {
-    items.forEach(({
-      item,
-      value
-    }) => item.set(value));
-    return;
-  }
-  const useRawBatchPath = items.every(({
-    item
-  }) => canUseRawBatchPath(asInternal(item)));
-  if (!useRawBatchPath) {
-    items.forEach(({
-      item,
-      value
-    }) => item.set(value));
-    return;
-  }
-  const keys = items.map(entry => entry.item.key);
-  const values = items.map(entry => entry.item.serialize(entry.value));
-  if (scope === _Storage.StorageScope.Secure) {
-    flushSecureWrites();
-  }
-  WebStorage.setBatch(keys, values, scope);
-  keys.forEach((key, index) => cacheRawValue(scope, key, values[index]));
+  measureOperation("batch:set", scope, () => {
+    (0, _internal.assertBatchScope)(items.map(batchEntry => batchEntry.item), scope);
+    if (scope === _Storage.StorageScope.Memory) {
+      items.forEach(({
+        item,
+        value
+      }) => item.set(value));
+      return;
+    }
+    if (scope === _Storage.StorageScope.Secure) {
+      const secureEntries = items.map(({
+        item,
+        value
+      }) => ({
+        item,
+        value,
+        internal: asInternal(item)
+      }));
+      const canUseSecureBatchPath = secureEntries.every(({
+        internal
+      }) => canUseSecureRawBatchPath(internal));
+      if (!canUseSecureBatchPath) {
+        items.forEach(({
+          item,
+          value
+        }) => item.set(value));
+        return;
+      }
+      flushSecureWrites();
+      const groupedByAccessControl = new Map();
+      secureEntries.forEach(({
+        item,
+        value,
+        internal
+      }) => {
+        const accessControl = internal._secureAccessControl ?? _Storage.AccessControl.WhenUnlocked;
+        const existingGroup = groupedByAccessControl.get(accessControl);
+        const group = existingGroup ?? {
+          keys: [],
+          values: []
+        };
+        group.keys.push(item.key);
+        group.values.push(item.serialize(value));
+        if (!existingGroup) {
+          groupedByAccessControl.set(accessControl, group);
+        }
+      });
+      groupedByAccessControl.forEach((group, accessControl) => {
+        WebStorage.setSecureAccessControl(accessControl);
+        WebStorage.setBatch(group.keys, group.values, scope);
+        group.keys.forEach((key, index) => cacheRawValue(scope, key, group.values[index]));
+      });
+      return;
+    }
+    const useRawBatchPath = items.every(({
+      item
+    }) => canUseRawBatchPath(asInternal(item)));
+    if (!useRawBatchPath) {
+      items.forEach(({
+        item,
+        value
+      }) => item.set(value));
+      return;
+    }
+    const keys = items.map(entry => entry.item.key);
+    const values = items.map(entry => entry.item.serialize(entry.value));
+    WebStorage.setBatch(keys, values, scope);
+    keys.forEach((key, index) => cacheRawValue(scope, key, values[index]));
+  }, items.length);
 }
 function removeBatch(items, scope) {
-  (0, _internal.assertBatchScope)(items, scope);
-  if (scope === _Storage.StorageScope.Memory) {
-    items.forEach(item => item.delete());
-    return;
-  }
-  const keys = items.map(item => item.key);
-  if (scope === _Storage.StorageScope.Secure) {
-    flushSecureWrites();
-  }
-  WebStorage.removeBatch(keys, scope);
-  keys.forEach(key => cacheRawValue(scope, key, undefined));
+  measureOperation("batch:remove", scope, () => {
+    (0, _internal.assertBatchScope)(items, scope);
+    if (scope === _Storage.StorageScope.Memory) {
+      items.forEach(item => item.delete());
+      return;
+    }
+    const keys = items.map(item => item.key);
+    if (scope === _Storage.StorageScope.Secure) {
+      flushSecureWrites();
+    }
+    WebStorage.removeBatch(keys, scope);
+    keys.forEach(key => cacheRawValue(scope, key, undefined));
+  }, items.length);
 }
 function registerMigration(version, migration) {
   if (!Number.isInteger(version) || version <= 0) {
@@ -842,93 +1243,133 @@ function registerMigration(version, migration) {
   registeredMigrations.set(version, migration);
 }
 function migrateToLatest(scope = _Storage.StorageScope.Disk) {
-  (0, _internal.assertValidScope)(scope);
-  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);
-    writeMigrationVersion(scope, version);
-    appliedVersion = version;
+  return measureOperation("migration:run", scope, () => {
+    (0, _internal.assertValidScope)(scope);
+    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);
+      writeMigrationVersion(scope, version);
+      appliedVersion = version;
+    });
+    return appliedVersion;
   });
-  return appliedVersion;
 }
 function runTransaction(scope, transaction) {
-  (0, _internal.assertValidScope)(scope);
-  if (scope === _Storage.StorageScope.Secure) {
-    flushSecureWrites();
-  }
-  const rollback = new Map();
-  const rememberRollback = key => {
-    if (rollback.has(key)) {
-      return;
-    }
-    rollback.set(key, getRawValue(key, scope));
-  };
-  const tx = {
-    scope,
-    getRaw: key => getRawValue(key, scope),
-    setRaw: (key, value) => {
-      rememberRollback(key);
-      setRawValue(key, value, scope);
-    },
-    removeRaw: key => {
-      rememberRollback(key);
-      removeRawValue(key, scope);
-    },
-    getItem: item => {
-      (0, _internal.assertBatchScope)([item], scope);
-      return item.get();
-    },
-    setItem: (item, value) => {
-      (0, _internal.assertBatchScope)([item], scope);
-      rememberRollback(item.key);
-      item.set(value);
-    },
-    removeItem: item => {
-      (0, _internal.assertBatchScope)([item], scope);
-      rememberRollback(item.key);
-      item.delete();
+  return measureOperation("transaction:run", scope, () => {
+    (0, _internal.assertValidScope)(scope);
+    if (scope === _Storage.StorageScope.Secure) {
+      flushSecureWrites();
     }
-  };
-  try {
-    return transaction(tx);
-  } catch (error) {
-    Array.from(rollback.entries()).reverse().forEach(([key, previousValue]) => {
-      if (previousValue === undefined) {
+    const rollback = new Map();
+    const rememberRollback = key => {
+      if (rollback.has(key)) {
+        return;
+      }
+      rollback.set(key, getRawValue(key, scope));
+    };
+    const tx = {
+      scope,
+      getRaw: key => getRawValue(key, scope),
+      setRaw: (key, value) => {
+        rememberRollback(key);
+        setRawValue(key, value, scope);
+      },
+      removeRaw: key => {
+        rememberRollback(key);
         removeRawValue(key, scope);
+      },
+      getItem: item => {
+        (0, _internal.assertBatchScope)([item], scope);
+        return item.get();
+      },
+      setItem: (item, value) => {
+        (0, _internal.assertBatchScope)([item], scope);
+        rememberRollback(item.key);
+        item.set(value);
+      },
+      removeItem: item => {
+        (0, _internal.assertBatchScope)([item], scope);
+        rememberRollback(item.key);
+        item.delete();
+      }
+    };
+    try {
+      return transaction(tx);
+    } catch (error) {
+      const rollbackEntries = Array.from(rollback.entries()).reverse();
+      if (scope === _Storage.StorageScope.Memory) {
+        rollbackEntries.forEach(([key, previousValue]) => {
+          if (previousValue === undefined) {
+            removeRawValue(key, scope);
+          } else {
+            setRawValue(key, previousValue, scope);
+          }
+        });
       } else {
-        setRawValue(key, previousValue, scope);
+        const keysToSet = [];
+        const valuesToSet = [];
+        const keysToRemove = [];
+        rollbackEntries.forEach(([key, previousValue]) => {
+          if (previousValue === undefined) {
+            keysToRemove.push(key);
+          } else {
+            keysToSet.push(key);
+            valuesToSet.push(previousValue);
+          }
+        });
+        if (scope === _Storage.StorageScope.Secure) {
+          flushSecureWrites();
+        }
+        if (keysToSet.length > 0) {
+          WebStorage.setBatch(keysToSet, valuesToSet, scope);
+          keysToSet.forEach((key, index) => cacheRawValue(scope, key, valuesToSet[index]));
+        }
+        if (keysToRemove.length > 0) {
+          WebStorage.removeBatch(keysToRemove, scope);
+          keysToRemove.forEach(key => cacheRawValue(scope, key, undefined));
+        }
       }
-    });
-    throw error;
-  }
+      throw error;
+    }
+  });
 }
 function createSecureAuthStorage(config, options) {
   const ns = options?.namespace ?? "auth";
   const result = {};
-  for (const key of Object.keys(config)) {
+  for (const key of typedKeys(config)) {
     const itemConfig = config[key];
+    const expirationConfig = itemConfig.ttlMs !== undefined ? {
+      ttlMs: itemConfig.ttlMs
+    } : undefined;
     result[key] = createStorageItem({
       key,
       scope: _Storage.StorageScope.Secure,
       defaultValue: "",
       namespace: ns,
-      biometric: itemConfig.biometric,
-      accessControl: itemConfig.accessControl,
-      expiration: itemConfig.ttlMs ? {
-        ttlMs: itemConfig.ttlMs
-      } : undefined
+      ...(itemConfig.biometric !== undefined ? {
+        biometric: itemConfig.biometric
+      } : {}),
+      ...(itemConfig.biometricLevel !== undefined ? {
+        biometricLevel: itemConfig.biometricLevel
+      } : {}),
+      ...(itemConfig.accessControl !== undefined ? {
+        accessControl: itemConfig.accessControl
+      } : {}),
+      ...(expirationConfig !== undefined ? {
+        expiration: expirationConfig
+      } : {})
     });
   }
   return result;