react-native-nitro-storage 0.4.4 → 0.5.0

package/lib/commonjs/index.web.js

@@ -29,7 +29,15 @@ Object.defineProperty(exports, "createIndexedDBBackend", {
 });
 exports.createSecureAuthStorage = createSecureAuthStorage;
 exports.createStorageItem = createStorageItem;
+exports.flushWebStorageBackends = flushWebStorageBackends;
 exports.getBatch = getBatch;
+Object.defineProperty(exports, "getStorageErrorCode", {
+  enumerable: true,
+  get: function () {
+    return _storageRuntime.getStorageErrorCode;
+  }
+});
+exports.getWebDiskStorageBackend = getWebDiskStorageBackend;
 exports.getWebSecureStorageBackend = getWebSecureStorageBackend;
 exports.isKeychainLockedError = isKeychainLockedError;
 Object.defineProperty(exports, "migrateFromMMKV", {
@@ -43,6 +51,7 @@ exports.registerMigration = registerMigration;
 exports.removeBatch = removeBatch;
 exports.runTransaction = runTransaction;
 exports.setBatch = setBatch;
+exports.setWebDiskStorageBackend = setWebDiskStorageBackend;
 exports.setWebSecureStorageBackend = setWebSecureStorageBackend;
 exports.storage = void 0;
 Object.defineProperty(exports, "useSetStorage", {
@@ -65,6 +74,8 @@ Object.defineProperty(exports, "useStorageSelector", {
 });
 var _Storage = require("./Storage.types");
 var _internal = require("./internal");
+var _webStorageBackend = require("./web-storage-backend");
+var _storageRuntime = require("./storage-runtime");
 var _migration = require("./migration");
 var _storageHooks = require("./storage-hooks");
 var _indexeddbBackend = require("./indexeddb-backend");
@@ -81,20 +92,23 @@ const registeredMigrations = new Map();
 const runMicrotask = typeof queueMicrotask === "function" ? queueMicrotask : task => {
   Promise.resolve().then(task);
 };
+const now = typeof performance !== "undefined" && typeof performance.now === "function" ? () => performance.now() : () => Date.now();
 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 pendingDiskWrites = new Map();
+let diskFlushScheduled = false;
+let diskWritesAsync = false;
 const pendingSecureWrites = new Map();
 let secureFlushScheduled = false;
 let secureDefaultAccessControl = _Storage.AccessControl.WhenUnlocked;
 const SECURE_WEB_PREFIX = "__secure_";
 const BIOMETRIC_WEB_PREFIX = "__bio_";
 let hasWarnedAboutWebBiometricFallback = false;
-let hasWebStorageEventSubscription = false;
-let webStorageSubscriberCount = 0;
+let hasWindowStorageEventSubscription = false;
 let metricsObserver;
 const metricsCounters = new Map();
 function recordMetric(operation, scope, durationMs, keysCount = 1) {
@@ -121,61 +135,54 @@ function measureOperation(operation, scope, fn, keysCount = 1) {
   if (!metricsObserver) {
     return fn();
   }
-  const start = Date.now();
+  const start = now();
   try {
     return fn();
   } finally {
-    recordMetric(operation, scope, Date.now() - start, keysCount);
+    recordMetric(operation, scope, 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;
-    }
-  };
+function createDefaultDiskBackend() {
+  return (0, _webStorageBackend.createLocalStorageWebBackend)({
+    name: "localStorage:disk",
+    includeKey: key => !key.startsWith(SECURE_WEB_PREFIX) && !key.startsWith(BIOMETRIC_WEB_PREFIX)
+  });
 }
-let webSecureStorageBackend = createLocalStorageWebSecureBackend();
-let cachedSecureBrowserStorage;
-let cachedSecureBackendRef;
-function getBrowserStorage(scope) {
-  if (scope === _Storage.StorageScope.Disk) {
-    return globalThis.localStorage;
+function createDefaultSecureBackend() {
+  return (0, _webStorageBackend.createLocalStorageWebBackend)({
+    name: "localStorage:secure",
+    includeKey: key => key.startsWith(SECURE_WEB_PREFIX) || key.startsWith(BIOMETRIC_WEB_PREFIX)
+  });
+}
+let webDiskStorageBackend = createDefaultDiskBackend();
+let webSecureStorageBackend = createDefaultSecureBackend();
+const externalSyncUnsubscribers = new Map();
+function getBackendName(scope, backend) {
+  const scopeName = scope === _Storage.StorageScope.Disk ? "disk" : "secure";
+  return backend?.name ?? `web:${scopeName}`;
+}
+function getWebSecureEncryptionStatus(backend) {
+  return backend?.name === "localStorage:secure" ? "unavailable" : "unknown";
+}
+function createWebStorageError(scope, operation, error, backend) {
+  const backendName = getBackendName(scope, backend);
+  const message = error instanceof Error ? error.message : String(error ?? "Unknown error");
+  return new Error(`NitroStorage(web): ${operation} failed for ${backendName}: ${message}`);
+}
+function withWebBackendOperation(scope, operation, fn) {
+  const backend = scope === _Storage.StorageScope.Disk ? webDiskStorageBackend : webSecureStorageBackend;
+  if (!backend) {
+    throw new Error(`NitroStorage(web): ${operation} failed because no ${scope === _Storage.StorageScope.Disk ? "disk" : "secure"} backend is configured.`);
   }
-  if (scope === _Storage.StorageScope.Secure) {
-    if (!webSecureStorageBackend) {
-      return undefined;
-    }
-    if (cachedSecureBackendRef === webSecureStorageBackend && cachedSecureBrowserStorage) {
-      return cachedSecureBrowserStorage;
-    }
-    cachedSecureBackendRef = webSecureStorageBackend;
-    cachedSecureBrowserStorage = {
-      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;
-      }
-    };
-    return cachedSecureBrowserStorage;
+  try {
+    ensureExternalSyncSubscriptions();
+    return fn(backend);
+  } catch (error) {
+    throw createWebStorageError(scope, operation, error, backend);
   }
-  return undefined;
+}
+function getWebBackend(scope) {
+  return scope === _Storage.StorageScope.Disk ? webDiskStorageBackend : webSecureStorageBackend;
 }
 function toSecureStorageKey(key) {
   return `${SECURE_WEB_PREFIX}${key}`;
@@ -196,28 +203,21 @@ function hydrateWebScopeKeyIndex(scope) {
   if (hydratedWebScopeKeyIndex.has(scope)) {
     return;
   }
-  const storage = getBrowserStorage(scope);
+  const backend = getWebBackend(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));
-      }
+  const keys = backend?.getAllKeys() ?? [];
+  for (const key of keys) {
+    if (scope === _Storage.StorageScope.Disk) {
+      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);
@@ -226,65 +226,85 @@ function ensureWebScopeKeyIndex(scope) {
   hydrateWebScopeKeyIndex(scope);
   return getWebScopeKeyIndex(scope);
 }
-function handleWebStorageEvent(event) {
-  const key = event.key;
+function applyExternalChangeEvent(scope, key, newValue) {
   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));
+    clearScopeRawCache(scope);
+    ensureWebScopeKeyIndex(scope).clear();
+    notifyAllListeners(getScopedListeners(scope));
     return;
   }
-  if (key.startsWith(SECURE_WEB_PREFIX)) {
+  if (scope === _Storage.StorageScope.Secure && key.startsWith(SECURE_WEB_PREFIX)) {
     const plainKey = fromSecureStorageKey(key);
-    if (event.newValue === null) {
+    if (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);
+      cacheRawValue(_Storage.StorageScope.Secure, plainKey, newValue);
     }
     notifyKeyListeners(getScopedListeners(_Storage.StorageScope.Secure), plainKey);
     return;
   }
-  if (key.startsWith(BIOMETRIC_WEB_PREFIX)) {
+  if (scope === _Storage.StorageScope.Secure && key.startsWith(BIOMETRIC_WEB_PREFIX)) {
     const plainKey = fromBiometricStorageKey(key);
-    if (event.newValue === null) {
-      if (getBrowserStorage(_Storage.StorageScope.Secure)?.getItem(toSecureStorageKey(plainKey)) === null) {
+    if (newValue === null) {
+      if (withWebBackendOperation(_Storage.StorageScope.Secure, "external-sync:getItem", backend => backend.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);
+      cacheRawValue(_Storage.StorageScope.Secure, plainKey, newValue);
     }
     notifyKeyListeners(getScopedListeners(_Storage.StorageScope.Secure), plainKey);
     return;
   }
-  if (event.newValue === null) {
-    ensureWebScopeKeyIndex(_Storage.StorageScope.Disk).delete(key);
-    cacheRawValue(_Storage.StorageScope.Disk, key, undefined);
+  if (newValue === null) {
+    ensureWebScopeKeyIndex(scope).delete(key);
+    cacheRawValue(scope, key, undefined);
   } else {
-    ensureWebScopeKeyIndex(_Storage.StorageScope.Disk).add(key);
-    cacheRawValue(_Storage.StorageScope.Disk, key, event.newValue);
+    ensureWebScopeKeyIndex(scope).add(key);
+    cacheRawValue(scope, key, newValue);
   }
-  notifyKeyListeners(getScopedListeners(_Storage.StorageScope.Disk), key);
+  notifyKeyListeners(getScopedListeners(scope), key);
 }
-function ensureWebStorageEventSubscription() {
-  webStorageSubscriberCount += 1;
-  if (webStorageSubscriberCount === 1 && typeof window !== "undefined" && typeof window.addEventListener === "function") {
-    window.addEventListener("storage", handleWebStorageEvent);
-    hasWebStorageEventSubscription = true;
+function handleWebStorageEvent(event) {
+  const key = event.key;
+  if (key === null) {
+    applyExternalChangeEvent(_Storage.StorageScope.Disk, null, null);
+    applyExternalChangeEvent(_Storage.StorageScope.Secure, null, null);
+    return;
+  }
+  if (key.startsWith(SECURE_WEB_PREFIX) || key.startsWith(BIOMETRIC_WEB_PREFIX)) {
+    applyExternalChangeEvent(_Storage.StorageScope.Secure, key, event.newValue);
+    return;
+  }
+  applyExternalChangeEvent(_Storage.StorageScope.Disk, key, event.newValue);
+}
+function subscribeToBackendChanges(scope) {
+  if (externalSyncUnsubscribers.has(scope)) {
+    return;
+  }
+  const backend = getWebBackend(scope);
+  if (!backend?.subscribe) {
+    return;
   }
+  const unsubscribe = backend.subscribe(event => {
+    applyExternalChangeEvent(scope, event.key, event.newValue);
+  });
+  externalSyncUnsubscribers.set(scope, unsubscribe);
 }
-function maybeCleanupWebStorageSubscription() {
-  webStorageSubscriberCount = Math.max(0, webStorageSubscriberCount - 1);
-  if (webStorageSubscriberCount === 0 && hasWebStorageEventSubscription && typeof window !== "undefined") {
-    window.removeEventListener("storage", handleWebStorageEvent);
-    hasWebStorageEventSubscription = false;
+function resetBackendChangeSubscription(scope) {
+  externalSyncUnsubscribers.get(scope)?.();
+  externalSyncUnsubscribers.delete(scope);
+}
+function ensureExternalSyncSubscriptions() {
+  if (!hasWindowStorageEventSubscription && typeof window !== "undefined" && typeof window.addEventListener === "function") {
+    window.addEventListener("storage", handleWebStorageEvent);
+    hasWindowStorageEventSubscription = true;
   }
+  subscribeToBackendChanges(_Storage.StorageScope.Disk);
+  subscribeToBackendChanges(_Storage.StorageScope.Secure);
 }
 function getScopedListeners(scope) {
   return webScopeListeners.get(scope);
@@ -340,12 +360,49 @@ function addKeyListener(registry, key, listener) {
 function readPendingSecureWrite(key) {
   return pendingSecureWrites.get(key)?.value;
 }
+function readPendingDiskWrite(key) {
+  return pendingDiskWrites.get(key)?.value;
+}
+function hasPendingDiskWrite(key) {
+  return pendingDiskWrites.has(key);
+}
 function hasPendingSecureWrite(key) {
   return pendingSecureWrites.has(key);
 }
+function clearPendingDiskWrite(key) {
+  pendingDiskWrites.delete(key);
+}
 function clearPendingSecureWrite(key) {
   pendingSecureWrites.delete(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) {
+    WebStorage.setBatch(keysToSet, valuesToSet, _Storage.StorageScope.Disk);
+  }
+  if (keysToRemove.length > 0) {
+    WebStorage.removeBatch(keysToRemove, _Storage.StorageScope.Disk);
+  }
+}
 function flushSecureWrites() {
   secureFlushScheduled = false;
   if (pendingSecureWrites.size === 0) {
@@ -384,6 +441,17 @@ function flushSecureWrites() {
     WebStorage.removeBatch(keysToRemove, _Storage.StorageScope.Secure);
   }
 }
+function scheduleDiskWrite(key, value) {
+  pendingDiskWrites.set(key, {
+    key,
+    value
+  });
+  if (diskFlushScheduled) {
+    return;
+  }
+  diskFlushScheduled = true;
+  runMicrotask(flushDiskWrites);
+}
 function scheduleSecureWrite(key, value, accessControl) {
   const pendingWrite = {
     key,
@@ -404,117 +472,124 @@ const WebStorage = {
   equals: other => other === WebStorage,
   dispose: () => {},
   set: (key, value, scope) => {
-    const storage = getBrowserStorage(scope);
-    if (!storage) {
+    if (scope !== _Storage.StorageScope.Disk && scope !== _Storage.StorageScope.Secure) {
       return;
     }
     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);
-    }
+    withWebBackendOperation(scope, "set", backend => {
+      backend.setItem(storageKey, value);
+    });
+    ensureWebScopeKeyIndex(scope).add(key);
+    notifyKeyListeners(getScopedListeners(scope), key);
   },
   get: (key, scope) => {
-    const storage = getBrowserStorage(scope);
+    if (scope !== _Storage.StorageScope.Disk && scope !== _Storage.StorageScope.Secure) {
+      return undefined;
+    }
     const storageKey = scope === _Storage.StorageScope.Secure ? toSecureStorageKey(key) : key;
-    return storage?.getItem(storageKey) ?? undefined;
+    const value = withWebBackendOperation(scope, "get", backend => backend.getItem(storageKey));
+    return value ?? undefined;
   },
   remove: (key, scope) => {
-    const storage = getBrowserStorage(scope);
-    if (!storage) {
+    if (scope !== _Storage.StorageScope.Disk && scope !== _Storage.StorageScope.Secure) {
       return;
     }
     if (scope === _Storage.StorageScope.Secure) {
-      storage.removeItem(toSecureStorageKey(key));
-      storage.removeItem(toBiometricStorageKey(key));
+      withWebBackendOperation(scope, "remove", backend => {
+        if (backend.removeMany) {
+          backend.removeMany([toSecureStorageKey(key), toBiometricStorageKey(key)]);
+          return;
+        }
+        backend.removeItem(toSecureStorageKey(key));
+        backend.removeItem(toBiometricStorageKey(key));
+      });
     } else {
-      storage.removeItem(key);
-    }
-    if (scope === _Storage.StorageScope.Disk || scope === _Storage.StorageScope.Secure) {
-      ensureWebScopeKeyIndex(scope).delete(key);
-      notifyKeyListeners(getScopedListeners(scope), key);
+      withWebBackendOperation(scope, "remove", backend => {
+        backend.removeItem(key);
+      });
     }
+    ensureWebScopeKeyIndex(scope).delete(key);
+    notifyKeyListeners(getScopedListeners(scope), key);
   },
   clear: scope => {
-    const storage = getBrowserStorage(scope);
-    if (!storage) {
+    if (scope !== _Storage.StorageScope.Disk && scope !== _Storage.StorageScope.Secure) {
       return;
     }
-    if (scope === _Storage.StorageScope.Secure) {
-      const keysToRemove = [];
-      for (let i = 0; i < storage.length; i++) {
-        const key = storage.key(i);
-        if (key?.startsWith(SECURE_WEB_PREFIX) || key?.startsWith(BIOMETRIC_WEB_PREFIX)) {
-          keysToRemove.push(key);
-        }
-      }
-      keysToRemove.forEach(key => storage.removeItem(key));
-    } else if (scope === _Storage.StorageScope.Disk) {
-      const keysToRemove = [];
-      for (let i = 0; i < storage.length; i++) {
-        const key = storage.key(i);
-        if (key && !key.startsWith(SECURE_WEB_PREFIX) && !key.startsWith(BIOMETRIC_WEB_PREFIX)) {
-          keysToRemove.push(key);
-        }
-      }
-      keysToRemove.forEach(key => storage.removeItem(key));
-    } else {
-      storage.clear();
-    }
-    if (scope === _Storage.StorageScope.Disk || scope === _Storage.StorageScope.Secure) {
-      ensureWebScopeKeyIndex(scope).clear();
-      notifyAllListeners(getScopedListeners(scope));
-    }
+    withWebBackendOperation(scope, "clear", backend => {
+      backend.clear();
+    });
+    ensureWebScopeKeyIndex(scope).clear();
+    notifyAllListeners(getScopedListeners(scope));
   },
   setBatch: (keys, values, scope) => {
-    const storage = getBrowserStorage(scope);
-    if (!storage) {
+    if (scope !== _Storage.StorageScope.Disk && scope !== _Storage.StorageScope.Secure) {
       return;
     }
+    const entries = [];
     keys.forEach((key, index) => {
       const value = values[index];
       if (value === undefined) {
         return;
       }
-      const storageKey = scope === _Storage.StorageScope.Secure ? toSecureStorageKey(key) : key;
-      storage.setItem(storageKey, value);
+      entries.push([scope === _Storage.StorageScope.Secure ? toSecureStorageKey(key) : key, 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));
-    }
+    withWebBackendOperation(scope, "setBatch", backend => {
+      if (backend.setMany) {
+        backend.setMany(entries);
+        return;
+      }
+      entries.forEach(([storageKey, value]) => {
+        backend.setItem(storageKey, value);
+      });
+    });
+    const keyIndex = ensureWebScopeKeyIndex(scope);
+    keys.forEach(key => keyIndex.add(key));
+    const listeners = getScopedListeners(scope);
+    keys.forEach(key => notifyKeyListeners(listeners, key));
   },
   getBatch: (keys, scope) => {
-    const storage = getBrowserStorage(scope);
-    return keys.map(key => {
-      const storageKey = scope === _Storage.StorageScope.Secure ? toSecureStorageKey(key) : key;
-      return storage?.getItem(storageKey) ?? undefined;
+    if (scope !== _Storage.StorageScope.Disk && scope !== _Storage.StorageScope.Secure) {
+      return keys.map(() => undefined);
+    }
+    const storageKeys = keys.map(key => scope === _Storage.StorageScope.Secure ? toSecureStorageKey(key) : key);
+    const values = withWebBackendOperation(scope, "getBatch", backend => {
+      if (backend.getMany) {
+        return backend.getMany(storageKeys);
+      }
+      return storageKeys.map(storageKey => backend.getItem(storageKey));
     });
+    return values.map(value => value ?? undefined);
   },
   removeBatch: (keys, scope) => {
-    const storage = getBrowserStorage(scope);
-    if (!storage) {
+    if (scope !== _Storage.StorageScope.Disk && scope !== _Storage.StorageScope.Secure) {
       return;
     }
     if (scope === _Storage.StorageScope.Secure) {
-      keys.forEach(key => {
-        storage.removeItem(toSecureStorageKey(key));
-        storage.removeItem(toBiometricStorageKey(key));
+      const storageKeys = keys.flatMap(key => [toSecureStorageKey(key), toBiometricStorageKey(key)]);
+      withWebBackendOperation(scope, "removeBatch", backend => {
+        if (backend.removeMany) {
+          backend.removeMany(storageKeys);
+          return;
+        }
+        storageKeys.forEach(storageKey => {
+          backend.removeItem(storageKey);
+        });
       });
     } else {
-      keys.forEach(key => {
-        storage.removeItem(key);
+      withWebBackendOperation(scope, "removeBatch", backend => {
+        if (backend.removeMany) {
+          backend.removeMany(keys);
+          return;
+        }
+        keys.forEach(key => {
+          backend.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));
-    }
+    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) {
@@ -531,11 +606,13 @@ const WebStorage = {
     return () => {};
   },
   has: (key, scope) => {
-    const storage = getBrowserStorage(scope);
     if (scope === _Storage.StorageScope.Secure) {
-      return storage?.getItem(toSecureStorageKey(key)) !== null || storage?.getItem(toBiometricStorageKey(key)) !== null;
+      return withWebBackendOperation(scope, "has", backend => backend.getItem(toSecureStorageKey(key))) !== null || withWebBackendOperation(scope, "has", backend => backend.getItem(toBiometricStorageKey(key))) !== null;
+    }
+    if (scope !== _Storage.StorageScope.Disk) {
+      return false;
     }
-    return storage?.getItem(key) !== null;
+    return withWebBackendOperation(scope, "has", backend => backend.getItem(key)) !== null;
   },
   getAllKeys: scope => {
     if (scope !== _Storage.StorageScope.Disk && scope !== _Storage.StorageScope.Secure) {
@@ -566,40 +643,43 @@ const WebStorage = {
       hasWarnedAboutWebBiometricFallback = true;
       console.warn("[NitroStorage] Biometric storage is not supported on web. Using localStorage.");
     }
-    getBrowserStorage(_Storage.StorageScope.Secure)?.setItem(toBiometricStorageKey(key), value);
+    withWebBackendOperation(_Storage.StorageScope.Secure, "setSecureBiometric", backend => backend.setItem(toBiometricStorageKey(key), value));
     ensureWebScopeKeyIndex(_Storage.StorageScope.Secure).add(key);
     notifyKeyListeners(getScopedListeners(_Storage.StorageScope.Secure), key);
   },
   getSecureBiometric: key => {
-    return getBrowserStorage(_Storage.StorageScope.Secure)?.getItem(toBiometricStorageKey(key)) ?? undefined;
+    const value = withWebBackendOperation(_Storage.StorageScope.Secure, "getSecureBiometric", backend => backend.getItem(toBiometricStorageKey(key)));
+    return value ?? undefined;
   },
   deleteSecureBiometric: key => {
-    const storage = getBrowserStorage(_Storage.StorageScope.Secure);
-    storage?.removeItem(toBiometricStorageKey(key));
-    if (storage?.getItem(toSecureStorageKey(key)) === null) {
+    withWebBackendOperation(_Storage.StorageScope.Secure, "deleteSecureBiometric", backend => backend.removeItem(toBiometricStorageKey(key)));
+    if (withWebBackendOperation(_Storage.StorageScope.Secure, "deleteSecureBiometric:getItem", backend => backend.getItem(toSecureStorageKey(key))) === null) {
       ensureWebScopeKeyIndex(_Storage.StorageScope.Secure).delete(key);
     }
     notifyKeyListeners(getScopedListeners(_Storage.StorageScope.Secure), key);
   },
   hasSecureBiometric: key => {
-    return getBrowserStorage(_Storage.StorageScope.Secure)?.getItem(toBiometricStorageKey(key)) !== null;
+    return withWebBackendOperation(_Storage.StorageScope.Secure, "hasSecureBiometric", backend => backend.getItem(toBiometricStorageKey(key))) !== null;
   },
   clearSecureBiometric: () => {
-    const storage = getBrowserStorage(_Storage.StorageScope.Secure);
-    if (!storage) return;
-    const keysToNotify = [];
-    const toRemove = [];
-    for (let i = 0; i < storage.length; i++) {
-      const k = storage.key(i);
-      if (k?.startsWith(BIOMETRIC_WEB_PREFIX)) {
-        toRemove.push(k);
-        keysToNotify.push(fromBiometricStorageKey(k));
-      }
+    const storageKeys = withWebBackendOperation(_Storage.StorageScope.Secure, "clearSecureBiometric:getAllKeys", backend => backend.getAllKeys());
+    const keysToNotify = storageKeys.filter(key => key.startsWith(BIOMETRIC_WEB_PREFIX)).map(key => fromBiometricStorageKey(key));
+    if (keysToNotify.length === 0) {
+      return;
     }
-    toRemove.forEach(k => storage.removeItem(k));
+    withWebBackendOperation(_Storage.StorageScope.Secure, "clearSecureBiometric", backend => {
+      const biometricKeys = keysToNotify.map(key => toBiometricStorageKey(key));
+      if (backend.removeMany) {
+        backend.removeMany(biometricKeys);
+        return;
+      }
+      biometricKeys.forEach(storageKey => {
+        backend.removeItem(storageKey);
+      });
+    });
     const keyIndex = ensureWebScopeKeyIndex(_Storage.StorageScope.Secure);
     keysToNotify.forEach(key => {
-      if (storage.getItem(toSecureStorageKey(key)) === null) {
+      if (withWebBackendOperation(_Storage.StorageScope.Secure, "clearSecureBiometric:getItem", backend => backend.getItem(toSecureStorageKey(key))) === null) {
         keyIndex.delete(key);
       }
     });
@@ -613,6 +693,9 @@ function getRawValue(key, scope) {
     const value = memoryStore.get(key);
     return typeof value === "string" ? value : undefined;
   }
+  if (scope === _Storage.StorageScope.Disk && hasPendingDiskWrite(key)) {
+    return readPendingDiskWrite(key);
+  }
   if (scope === _Storage.StorageScope.Secure && hasPendingSecureWrite(key)) {
     return readPendingSecureWrite(key);
   }
@@ -625,6 +708,15 @@ function setRawValue(key, value, scope) {
     notifyKeyListeners(memoryListeners, key);
     return;
   }
+  if (scope === _Storage.StorageScope.Disk) {
+    cacheRawValue(scope, key, value);
+    if (diskWritesAsync) {
+      scheduleDiskWrite(key, value);
+      return;
+    }
+    flushDiskWrites();
+    clearPendingDiskWrite(key);
+  }
   if (scope === _Storage.StorageScope.Secure) {
     flushSecureWrites();
     clearPendingSecureWrite(key);
@@ -639,6 +731,15 @@ function removeRawValue(key, scope) {
     notifyKeyListeners(memoryListeners, key);
     return;
   }
+  if (scope === _Storage.StorageScope.Disk) {
+    cacheRawValue(scope, key, undefined);
+    if (diskWritesAsync) {
+      scheduleDiskWrite(key, undefined);
+      return;
+    }
+    flushDiskWrites();
+    clearPendingDiskWrite(key);
+  }
   if (scope === _Storage.StorageScope.Secure) {
     flushSecureWrites();
     clearPendingSecureWrite(key);
@@ -665,6 +766,10 @@ const storage = exports.storage = {
         notifyAllListeners(memoryListeners);
         return;
       }
+      if (scope === _Storage.StorageScope.Disk) {
+        flushDiskWrites();
+        pendingDiskWrites.clear();
+      }
       if (scope === _Storage.StorageScope.Secure) {
         flushSecureWrites();
         pendingSecureWrites.clear();
@@ -693,6 +798,9 @@ const storage = exports.storage = {
         return;
       }
       const keyPrefix = (0, _internal.prefixKey)(namespace, "");
+      if (scope === _Storage.StorageScope.Disk) {
+        flushDiskWrites();
+      }
       if (scope === _Storage.StorageScope.Secure) {
         flushSecureWrites();
       }
@@ -714,6 +822,12 @@ const storage = exports.storage = {
     return measureOperation("storage:has", scope, () => {
       (0, _internal.assertValidScope)(scope);
       if (scope === _Storage.StorageScope.Memory) return memoryStore.has(key);
+      if (scope === _Storage.StorageScope.Disk) {
+        flushDiskWrites();
+      }
+      if (scope === _Storage.StorageScope.Secure) {
+        flushSecureWrites();
+      }
       return WebStorage.has(key, scope);
     });
   },
@@ -721,6 +835,12 @@ const storage = exports.storage = {
     return measureOperation("storage:getAllKeys", scope, () => {
       (0, _internal.assertValidScope)(scope);
       if (scope === _Storage.StorageScope.Memory) return Array.from(memoryStore.keys());
+      if (scope === _Storage.StorageScope.Disk) {
+        flushDiskWrites();
+      }
+      if (scope === _Storage.StorageScope.Secure) {
+        flushSecureWrites();
+      }
       return WebStorage.getAllKeys(scope);
     });
   },
@@ -730,6 +850,12 @@ const storage = exports.storage = {
       if (scope === _Storage.StorageScope.Memory) {
         return Array.from(memoryStore.keys()).filter(key => key.startsWith(prefix));
       }
+      if (scope === _Storage.StorageScope.Disk) {
+        flushDiskWrites();
+      }
+      if (scope === _Storage.StorageScope.Secure) {
+        flushSecureWrites();
+      }
       return WebStorage.getKeysByPrefix(prefix, scope);
     });
   },
@@ -749,6 +875,12 @@ const storage = exports.storage = {
         });
         return result;
       }
+      if (scope === _Storage.StorageScope.Disk) {
+        flushDiskWrites();
+      }
+      if (scope === _Storage.StorageScope.Secure) {
+        flushSecureWrites();
+      }
       const values = WebStorage.getBatch(keys, scope);
       keys.forEach((key, index) => {
         const value = values[index];
@@ -769,6 +901,12 @@ const storage = exports.storage = {
         });
         return result;
       }
+      if (scope === _Storage.StorageScope.Disk) {
+        flushDiskWrites();
+      }
+      if (scope === _Storage.StorageScope.Secure) {
+        flushSecureWrites();
+      }
       const keys = WebStorage.getAllKeys(scope);
       if (keys.length === 0) return {};
       const values = WebStorage.getBatch(keys, scope);
@@ -785,6 +923,12 @@ const storage = exports.storage = {
     return measureOperation("storage:size", scope, () => {
       (0, _internal.assertValidScope)(scope);
       if (scope === _Storage.StorageScope.Memory) return memoryStore.size;
+      if (scope === _Storage.StorageScope.Disk) {
+        flushDiskWrites();
+      }
+      if (scope === _Storage.StorageScope.Secure) {
+        flushSecureWrites();
+      }
       return WebStorage.size(scope);
     });
   },
@@ -795,6 +939,19 @@ const storage = exports.storage = {
   setSecureWritesAsync: _enabled => {
     recordMetric("storage:setSecureWritesAsync", _Storage.StorageScope.Secure, 0);
   },
+  setDiskWritesAsync: enabled => {
+    measureOperation("storage:setDiskWritesAsync", _Storage.StorageScope.Disk, () => {
+      diskWritesAsync = enabled;
+      if (!enabled) {
+        flushDiskWrites();
+      }
+    });
+  },
+  flushDiskWrites: () => {
+    measureOperation("storage:flushDiskWrites", _Storage.StorageScope.Disk, () => {
+      flushDiskWrites();
+    });
+  },
   flushSecureWrites: () => {
     measureOperation("storage:flushSecureWrites", _Storage.StorageScope.Secure, () => {
       flushSecureWrites();
@@ -821,6 +978,69 @@ const storage = exports.storage = {
   resetMetrics: () => {
     metricsCounters.clear();
   },
+  getCapabilities: () => ({
+    platform: "web",
+    backend: {
+      disk: getBackendName(_Storage.StorageScope.Disk, webDiskStorageBackend),
+      secure: getBackendName(_Storage.StorageScope.Secure, webSecureStorageBackend)
+    },
+    writeBuffering: {
+      disk: true,
+      secure: true
+    },
+    errorClassification: true
+  }),
+  getSecurityCapabilities: () => {
+    const secureBackend = getBackendName(_Storage.StorageScope.Secure, webSecureStorageBackend);
+    return {
+      platform: "web",
+      secureStorage: {
+        backend: secureBackend,
+        encrypted: getWebSecureEncryptionStatus(webSecureStorageBackend),
+        accessControl: "unavailable",
+        keychainAccessGroup: "unavailable",
+        hardwareBacked: "unavailable"
+      },
+      biometric: {
+        storage: "unavailable",
+        prompt: "unavailable",
+        biometryOnly: "unavailable",
+        biometryOrPasscode: "unavailable"
+      },
+      metadata: {
+        perKey: true,
+        listsWithoutValues: true,
+        persistsTimestamps: false
+      }
+    };
+  },
+  getSecureMetadata: key => {
+    return measureOperation("storage:getSecureMetadata", _Storage.StorageScope.Secure, () => {
+      flushSecureWrites();
+      const biometricProtected = WebStorage.hasSecureBiometric(key);
+      const exists = biometricProtected || WebStorage.has(key, _Storage.StorageScope.Secure);
+      let kind = "missing";
+      if (exists) {
+        kind = biometricProtected ? "biometric" : "secure";
+      }
+      return {
+        key,
+        exists,
+        kind,
+        backend: getBackendName(_Storage.StorageScope.Secure, webSecureStorageBackend),
+        encrypted: getWebSecureEncryptionStatus(webSecureStorageBackend),
+        hardwareBacked: "unavailable",
+        biometricProtected,
+        valueExposed: false
+      };
+    });
+  },
+  getAllSecureMetadata: () => {
+    return measureOperation("storage:getAllSecureMetadata", _Storage.StorageScope.Secure, () => {
+      flushSecureWrites();
+      return WebStorage.getAllKeys(_Storage.StorageScope.Secure).map(key => storage.getSecureMetadata(key));
+    });
+  },
   getString: (key, scope) => {
     return measureOperation("storage:getString", scope, () => {
       return getRawValue(key, scope);
@@ -853,21 +1073,50 @@ const storage = exports.storage = {
         flushSecureWrites();
         WebStorage.setSecureAccessControl(secureDefaultAccessControl);
       }
+      if (scope === _Storage.StorageScope.Disk) {
+        flushDiskWrites();
+      }
       WebStorage.setBatch(keys, values, scope);
       keys.forEach((key, index) => cacheRawValue(scope, key, values[index]));
     }, keys.length);
   }
 };
 function setWebSecureStorageBackend(backend) {
-  webSecureStorageBackend = backend ?? createLocalStorageWebSecureBackend();
-  cachedSecureBrowserStorage = undefined;
-  cachedSecureBackendRef = undefined;
+  pendingSecureWrites.clear();
+  webSecureStorageBackend = backend ?? createDefaultSecureBackend();
+  resetBackendChangeSubscription(_Storage.StorageScope.Secure);
   hydratedWebScopeKeyIndex.delete(_Storage.StorageScope.Secure);
   clearScopeRawCache(_Storage.StorageScope.Secure);
+  ensureExternalSyncSubscriptions();
 }
 function getWebSecureStorageBackend() {
   return webSecureStorageBackend;
 }
+function setWebDiskStorageBackend(backend) {
+  pendingDiskWrites.clear();
+  webDiskStorageBackend = backend ?? createDefaultDiskBackend();
+  resetBackendChangeSubscription(_Storage.StorageScope.Disk);
+  hydratedWebScopeKeyIndex.delete(_Storage.StorageScope.Disk);
+  clearScopeRawCache(_Storage.StorageScope.Disk);
+  ensureExternalSyncSubscriptions();
+}
+function getWebDiskStorageBackend() {
+  return webDiskStorageBackend;
+}
+async function flushWebStorageBackends() {
+  flushDiskWrites();
+  flushSecureWrites();
+  const flushes = [];
+  const diskFlush = webDiskStorageBackend?.flush;
+  const secureFlush = webSecureStorageBackend?.flush;
+  if (diskFlush) {
+    flushes.push(diskFlush());
+  }
+  if (secureFlush) {
+    flushes.push(secureFlush());
+  }
+  await Promise.all(flushes);
+}
 function canUseRawBatchPath(item) {
   return item._hasExpiration === false && item._hasValidation === false && item._isBiometric !== true && item._secureAccessControl === undefined;
 }
@@ -895,6 +1144,7 @@ function createStorageItem(config) {
   const expirationTtlMs = expiration?.ttlMs;
   const memoryExpiration = expiration && isMemory ? new Map() : null;
   const readCache = !isMemory && config.readCache === true;
+  const coalesceDiskWrites = config.scope === _Storage.StorageScope.Disk && config.coalesceDiskWrites === true;
   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;
@@ -925,7 +1175,7 @@ function createStorageItem(config) {
       unsubscribe = addKeyListener(memoryListeners, storageKey, listener);
       return;
     }
-    ensureWebStorageEventSubscription();
+    ensureExternalSyncSubscriptions();
     unsubscribe = addKeyListener(getScopedListeners(nonMemoryScope), storageKey, listener);
   };
   const readStoredRaw = () => {
@@ -942,6 +1192,12 @@ function createStorageItem(config) {
       }
       return memoryStore.get(storageKey);
     }
+    if (nonMemoryScope === _Storage.StorageScope.Disk) {
+      const pending = pendingDiskWrites.get(storageKey);
+      if (pending !== undefined) {
+        return pending.value;
+      }
+    }
     if (nonMemoryScope === _Storage.StorageScope.Secure && !isBiometric) {
       const pending = pendingSecureWrites.get(storageKey);
       if (pending !== undefined) {
@@ -968,6 +1224,13 @@ function createStorageItem(config) {
       return;
     }
     cacheRawValue(nonMemoryScope, storageKey, rawValue);
+    if (nonMemoryScope === _Storage.StorageScope.Disk) {
+      if (coalesceDiskWrites || diskWritesAsync) {
+        scheduleDiskWrite(storageKey, rawValue);
+        return;
+      }
+      clearPendingDiskWrite(storageKey);
+    }
     if (coalesceSecureWrites) {
       scheduleSecureWrite(storageKey, rawValue, secureAccessControl ?? secureDefaultAccessControl);
       return;
@@ -983,6 +1246,13 @@ function createStorageItem(config) {
       return;
     }
     cacheRawValue(nonMemoryScope, storageKey, undefined);
+    if (nonMemoryScope === _Storage.StorageScope.Disk) {
+      if (coalesceDiskWrites || diskWritesAsync) {
+        scheduleDiskWrite(storageKey, undefined);
+        return;
+      }
+      clearPendingDiskWrite(storageKey);
+    }
     if (coalesceSecureWrites) {
       scheduleSecureWrite(storageKey, undefined, secureAccessControl ?? secureDefaultAccessControl);
       return;
@@ -1143,6 +1413,18 @@ function createStorageItem(config) {
   const hasItem = () => measureOperation("item:has", config.scope, () => {
     if (isMemory) return memoryStore.has(storageKey);
     if (isBiometric) return WebStorage.hasSecureBiometric(storageKey);
+    if (nonMemoryScope === _Storage.StorageScope.Disk) {
+      const pending = pendingDiskWrites.get(storageKey);
+      if (pending !== undefined) {
+        return pending.value !== undefined;
+      }
+    }
+    if (nonMemoryScope === _Storage.StorageScope.Secure) {
+      const pending = pendingSecureWrites.get(storageKey);
+      if (pending !== undefined) {
+        return pending.value !== undefined;
+      }
+    }
     return WebStorage.has(storageKey, config.scope);
   });
   const subscribe = callback => {
@@ -1153,9 +1435,6 @@ function createStorageItem(config) {
       if (listeners.size === 0 && unsubscribe) {
         unsubscribe();
         unsubscribe = null;
-        if (!isMemory) {
-          maybeCleanupWebStorageSubscription();
-        }
       }
     };
   };
@@ -1203,6 +1482,13 @@ function getBatch(items, scope) {
     const keysToFetch = [];
     const keyIndexes = [];
     items.forEach((item, index) => {
+      if (scope === _Storage.StorageScope.Disk) {
+        const pending = pendingDiskWrites.get(item.key);
+        if (pending !== undefined) {
+          rawValues[index] = pending.value;
+          return;
+        }
+      }
       if (scope === _Storage.StorageScope.Secure) {
         const pending = pendingSecureWrites.get(item.key);
         if (pending !== undefined) {
@@ -1319,6 +1605,7 @@ function setBatch(items, scope) {
       });
       return;
     }
+    flushDiskWrites();
     const useRawBatchPath = items.every(({
       item
     }) => canUseRawBatchPath(asInternal(item)));
@@ -1343,6 +1630,9 @@ function removeBatch(items, scope) {
       return;
     }
     const keys = items.map(item => item.key);
+    if (scope === _Storage.StorageScope.Disk) {
+      flushDiskWrites();
+    }
     if (scope === _Storage.StorageScope.Secure) {
       flushSecureWrites();
     }
@@ -1388,6 +1678,9 @@ function migrateToLatest(scope = _Storage.StorageScope.Disk) {
 function runTransaction(scope, transaction) {
   return measureOperation("transaction:run", scope, () => {
     (0, _internal.assertValidScope)(scope);
+    if (scope === _Storage.StorageScope.Disk) {
+      flushDiskWrites();
+    }
     if (scope === _Storage.StorageScope.Secure) {
       flushSecureWrites();
     }
@@ -1454,6 +1747,9 @@ function runTransaction(scope, transaction) {
             valuesToSet.push(previousValue);
           }
         });
+        if (scope === _Storage.StorageScope.Disk) {
+          flushDiskWrites();
+        }
         if (scope === _Storage.StorageScope.Secure) {
           flushSecureWrites();
         }
@@ -1499,7 +1795,7 @@ function createSecureAuthStorage(config, options) {
   }
   return result;
 }
-function isKeychainLockedError(_err) {
-  return false;
+function isKeychainLockedError(err) {
+  return (0, _storageRuntime.isLockedStorageErrorCode)((0, _storageRuntime.getStorageErrorCode)(err));
 }
 //# sourceMappingURL=index.web.js.map