react-native-nitro-storage 0.6.0 → 0.8.0

package/docs/batch-transactions-migrations.md

@@ -80,7 +80,7 @@ const snapshot = storage.export(StorageScope.Disk);
 storage.import(snapshot, StorageScope.Disk);
 ```
 
-For Memory scope, import is atomic: all keys are written before listeners fire. For Disk and Secure, import delegates to native or web batch paths.
+For Memory scope, import is atomic: all keys are written before listeners fire. Disk and Secure imports flush pending coalesced writes first, so the imported snapshot cannot be overwritten by an earlier pending flush, then delegate to native or web batch paths.
 
 Secure exports contain raw secret values. `storage.export(StorageScope.Secure)` requires `{ includeSecureValues: true }`; `storage.exportSecureUnsafe()` is the explicit equivalent. Do not log Secure exports or include them in diagnostics, analytics, crash reports, or support bundles.
 
@@ -124,7 +124,9 @@ Transaction context methods:
 - `setItem(item, value)`
 - `removeItem(item)`
 
-If the callback throws, Nitro Storage restores the keys it changed during that transaction.
+If the callback throws, Nitro Storage restores the keys it changed during that transaction and emits exactly one typed `rollback` batch event so observers and the global event observer can react to the rollback.
+
+Memory-scope batch removes are atomic: all keys are deleted before listeners fire, and scope, key, and prefix subscribers receive a single `removeBatch` event.
 
 ## Migrations
 
@@ -157,6 +159,8 @@ migrateToLatest(StorageScope.Disk);
 
 Migration context methods work with raw strings. Use item serializers manually when migrating structured data.
 
+Each migration step runs inside its own transaction together with the version marker write. A step that throws rolls back both its data changes and the version marker, so the scope stays on the last completed version and rerunning `migrateToLatest()` retries deterministically.
+
 ```ts
 registerMigration(3, (ctx) => {
   const raw = ctx.getRaw("settings");
@@ -198,3 +202,5 @@ const didWrite = themeItem.setIfVersion(
 ```
 
 `setIfVersion()` returns `false` if another write changed the item after `getWithVersion()`.
+
+Compare-and-set is optimistic: the version is read, compared, and written without backend-level atomicity. Two writers on different runtimes can both pass the check between their reads and writes, so use it for single-runtime coordination or last-writer-wins-tolerant flows. There is no native compare-and-swap primitive.

package/docs/benchmarks.md

@@ -2,36 +2,40 @@
 
 Benchmarks are release checks, not product promises. Use them to catch regressions on the local machine and CI image used by this repo.
 
-Run:
+Run from the repo root:
 
 ```sh
-bun run benchmark -- --filter=react-native-nitro-storage
+bun run build
+bun run benchmark
 ```
 
-The benchmark script checks representative synchronous read/write paths and fails when results drift beyond the configured threshold.
+## Scope: Web Only
+
+`benchmark` loads `lib/commonjs/index.web.js` and measures the web entry against the localStorage backend. The `disk:` and `secure:` labels describe web scopes, not native Disk or Secure storage.
+
+Native Disk/Secure baselines require a device or simulator run and are not part of this gate. Do not compare these numbers against native storage.
 
 ## Interpreting Results
 
 - Compare results on the same machine and Node/Bun version.
-- Treat large deltas as a prompt to inspect recent storage-runtime, serialization, native bridge, or cache changes.
+- Treat large deltas as a prompt to inspect recent storage-runtime, serialization, cache, or event changes.
 - Do not compare web backend numbers against native secure storage numbers; they measure different systems.
-- Secure storage performance depends on platform state, device lock state, biometric prompts, and Keystore/Keychain behavior.
 
 ## Release Checklist
 
 Before publishing:
 
 ```sh
-bun run lint -- --filter=react-native-nitro-storage
-bun run format:check -- --filter=react-native-nitro-storage
-bun run typecheck -- --filter=react-native-nitro-storage
-bun run test:types -- --filter=react-native-nitro-storage
-bun run test -- --filter=react-native-nitro-storage
-bun run test:cpp -- --filter=react-native-nitro-storage
-bun run build -- --filter=react-native-nitro-storage
-bun run benchmark -- --filter=react-native-nitro-storage
-(cd packages/react-native-nitro-storage && bun run check:pack)
-npm publish --dry-run
+bun run codegen:check
+bun run lint:check
+bun run format:check
+bun run typecheck
+bun run test:types
+bun run test
+bun run test:cpp
+bun run build
+bun run benchmark
+bun run --cwd packages/react-native-nitro-storage check:pack
 ```
 
 Keep the dry-publish output in the release notes when validating a version locally.

package/docs/secure-storage.md

@@ -47,6 +47,8 @@ export const recoveryCodeItem = createStorageItem<string>({
 
 `BiometricLevel.BiometryOnly` does not allow passcode fallback. Use `BiometricLevel.BiometryOrPasscode` when passcode fallback is acceptable.
 
+On Android 11 and newer, the two levels use separate Android Keystore keys with distinct allowed authenticators. Android 10 and older support `BiometryOrPasscode`; `BiometryOnly` reports `biometric_unavailable` because the older Keystore API cannot enforce that distinction safely for this storage backend. Android authorization remains valid for a 30-second window after successful authentication.
+
 ## Access Control
 
 `accessControl` maps to platform accessibility rules where available.
@@ -141,6 +143,8 @@ Android secure storage uses encrypted SharedPreferences. Restored encrypted pref
 
 - `NitroStorageSecure.xml`
 - `NitroStorageBiometric.xml`
+- `NitroStorageBiometricOrPasscode.xml`
+- `NitroStorageBiometricOnly.xml`
 
 If you disable `configureAndroidBackup` or maintain custom Android backup XML, add equivalent exclusions for both cloud backup and device transfer.
 

package/docs/web-backends.md

@@ -38,7 +38,7 @@ Optional methods improve performance and observability:
 
 `subscribe(listener)` should report `{ key, newValue }` changes. Use `key: null` when the whole backend is cleared.
 
-`close()` should release backend-owned resources such as database handles or broadcast channels. Nitro Storage calls it when a configured Disk or Secure backend is replaced.
+`close()` should release backend-owned resources such as database handles or broadcast channels. A replaced backend is retired instead of closed on the spot: `flushWebStorageBackends()` flushes it and then closes it, so queued async writes can commit before the connection goes away. Backends without `flush()` are closed immediately on replacement, and a retired backend whose flush fails stays retired for a later explicit retry.
 
 ## Disk Backend
 
@@ -100,6 +100,23 @@ Reads are synchronous because they are served from memory after initial load. Wr
 
 The IndexedDB backend exposes `close()` and rejects later synchronous operations after it is closed.
 
+### Persistence Lifecycle
+
+IndexedDB transactions cannot block a page unload, so in-flight writes may be aborted when the page closes. The backend mitigates this by starting a flush on `pagehide` and on `visibilitychange` (hidden), and `flush()` awaits every pending transaction. When persistence fails, `flush()` throws an error that names the affected keys, and `onError` receives each individual failure.
+
+```ts
+const backend = await createIndexedDBBackend("app-secure", "keyvalue", {
+  onError: (error) => {
+    console.error("IndexedDB secure storage failed", error);
+  },
+});
+
+// Before assertions, navigation, or lifecycle boundaries:
+await flushWebStorageBackends();
+```
+
+Treat IndexedDB persistence as best-effort under abrupt termination: keep a durable copy of critical values elsewhere if they must survive an immediate page close.
+
 ## Cross-tab Updates
 
 The IndexedDB backend uses `BroadcastChannel` when available. Other tabs receive cache invalidation events and update their in-memory copy.

package/ios/IOSStorageAdapterCpp.mm

@@ -8,6 +8,8 @@ namespace NitroStorage {
 static NSString* const kKeychainService = @"com.nitrostorage.keychain";
 static NSString* const kBiometricKeychainService = @"com.nitrostorage.biometric";
 static NSString* const kDiskSuiteName = @"com.nitrostorage.disk";
+static NSString* const kLegacyDiskKeysRegistryKey =
+    @"__nitro_storage_legacy_disk_keys__";
 
 static std::runtime_error taggedStorageError(const char* code, const std::string& message) {
     return std::runtime_error(
@@ -15,11 +17,69 @@ static std::runtime_error taggedStorageError(const char* code, const std::string
     );
 }
 
+// Unknown keychain statuses are surfaced untagged (matching Android's
+// cause-based wrapping), except errSecNotAvailable which means the keychain
+// is unavailable until the device is first unlocked — a locked condition.
+static std::runtime_error keychainStatusError(OSStatus status, const std::string& operation) {
+    if (status == errSecNotAvailable) {
+        return taggedStorageError(
+            "keychain_locked",
+            std::string("NitroStorage: ") + operation + " failed: keychain is unavailable until the device is unlocked (errSecNotAvailable)."
+        );
+    }
+    return std::runtime_error(
+        std::string("NitroStorage: ") + operation + " failed with status " + std::to_string(status)
+    );
+}
+
 static NSUserDefaults* NitroDiskDefaults() {
     static NSUserDefaults* defaults = [[NSUserDefaults alloc] initWithSuiteName:kDiskSuiteName];
     return defaults ?: [NSUserDefaults standardUserDefaults];
 }
 
+// --- Legacy disk key registry ---
+// Versions before the suite domain stored Disk values in standardUserDefaults.
+// The registry records legacy keys observed through the storage API so that
+// clearDisk can remove both stores and deleted legacy values cannot reappear.
+// Only keys observed through the storage API are ever registered; the host
+// app's own standard defaults keys are never enumerated or touched.
+
+static NSSet<NSString*>* registeredLegacyDiskKeys() {
+    NSArray* stored = [NitroDiskDefaults() stringArrayForKey:kLegacyDiskKeysRegistryKey];
+    return stored ? [NSSet setWithArray:stored] : [NSSet set];
+}
+
+static void persistLegacyDiskKeys(NSSet<NSString*>* keys) {
+    if (keys.count == 0) {
+        [NitroDiskDefaults() removeObjectForKey:kLegacyDiskKeysRegistryKey];
+        return;
+    }
+    [NitroDiskDefaults() setObject:[keys allObjects] forKey:kLegacyDiskKeysRegistryKey];
+}
+
+static void registerLegacyDiskKey(NSString* key) {
+    NSMutableSet* keys = [registeredLegacyDiskKeys() mutableCopy];
+    [keys addObject:key];
+    persistLegacyDiskKeys(keys);
+}
+
+static void unregisterLegacyDiskKeys(NSArray<NSString*>* keys) {
+    if (keys.count == 0) {
+        return;
+    }
+    NSMutableSet* registered = [registeredLegacyDiskKeys() mutableCopy];
+    BOOL changed = NO;
+    for (NSString* key in keys) {
+        if ([registered containsObject:key]) {
+            [registered removeObject:key];
+            changed = YES;
+        }
+    }
+    if (changed) {
+        persistLegacyDiskKeys(registered);
+    }
+}
+
 // Prevents the Keychain from showing auth UI. On iOS 14+ kSecUseAuthenticationUIFail is
 // deprecated; the correct replacement is an LAContext with interactionNotAllowed = YES.
 static void disableKeychainInteraction(NSMutableDictionary* query) {
@@ -52,6 +112,7 @@ void IOSStorageAdapterCpp::setDisk(const std::string& key, const std::string& va
     NSUserDefaults* standard = [NSUserDefaults standardUserDefaults];
     if ([standard objectForKey:nsKey] != nil) {
         [standard removeObjectForKey:nsKey];
+        unregisterLegacyDiskKeys(@[nsKey]);
     }
 }
 
@@ -66,6 +127,7 @@ std::optional<std::string> IOSStorageAdapterCpp::getDisk(const std::string& key)
         if (legacyValue) {
             [defaults setObject:legacyValue forKey:nsKey];
             [legacyDefaults removeObjectForKey:nsKey];
+            unregisterLegacyDiskKeys(@[nsKey]);
             result = legacyValue;
         }
     }
@@ -81,22 +143,40 @@ void IOSStorageAdapterCpp::deleteDisk(const std::string& key) {
     if ([standard objectForKey:nsKey] != nil) {
         [standard removeObjectForKey:nsKey];
     }
+    unregisterLegacyDiskKeys(@[nsKey]);
 }
 
 bool IOSStorageAdapterCpp::hasDisk(const std::string& key) {
     NSString* nsKey = [NSString stringWithUTF8String:key.c_str()];
     if ([NitroDiskDefaults() objectForKey:nsKey] != nil) return true;
     // Check legacy standardUserDefaults for un-migrated keys
-    return [[NSUserDefaults standardUserDefaults] stringForKey:nsKey] != nil;
+    if ([[NSUserDefaults standardUserDefaults] stringForKey:nsKey] != nil) {
+        registerLegacyDiskKey(nsKey);
+        return true;
+    }
+    return false;
 }
 
 std::vector<std::string> IOSStorageAdapterCpp::getAllKeysDisk() {
     NSUserDefaults* defaults = NitroDiskDefaults();
     NSDictionary<NSString*, id>* entries = [defaults persistentDomainForName:kDiskSuiteName] ?: @{};
-    std::vector<std::string> keys;
-    keys.reserve(entries.count);
+    std::unordered_set<std::string> combined;
     for (NSString* key in entries) {
-        keys.push_back(std::string([key UTF8String]));
+        if (![key isEqualToString:kLegacyDiskKeysRegistryKey]) {
+            combined.insert(std::string([key UTF8String]));
+        }
+    }
+    // Only keys observed through the storage API are registered legacy keys;
+    // arbitrary host-app standard defaults keys are never enumerated.
+    for (NSString* key in [registeredLegacyDiskKeys() allObjects]) {
+        if (entries[key] == nil && ![key isEqualToString:kLegacyDiskKeysRegistryKey]) {
+            combined.insert(std::string([key UTF8String]));
+        }
+    }
+    std::vector<std::string> keys;
+    keys.reserve(combined.size());
+    for (const auto& key : combined) {
+        keys.push_back(key);
     }
     return keys;
 }
@@ -114,8 +194,7 @@ std::vector<std::string> IOSStorageAdapterCpp::getKeysByPrefixDisk(const std::st
 }
 
 size_t IOSStorageAdapterCpp::sizeDisk() {
-    NSDictionary<NSString*, id>* entries = [NitroDiskDefaults() persistentDomainForName:kDiskSuiteName] ?: @{};
-    return entries.count;
+    return getAllKeysDisk().size();
 }
 
 void IOSStorageAdapterCpp::setDiskBatch(
@@ -136,6 +215,7 @@ void IOSStorageAdapterCpp::setDiskBatch(
     for (NSString* key in legacyKeysToRemove) {
         [standard removeObjectForKey:key];
     }
+    unregisterLegacyDiskKeys(legacyKeysToRemove);
 }
 
 std::vector<std::optional<std::string>> IOSStorageAdapterCpp::getDiskBatch(
@@ -158,9 +238,26 @@ void IOSStorageAdapterCpp::deleteDiskBatch(const std::vector<std::string>& keys)
 void IOSStorageAdapterCpp::clearDisk() {
     NSUserDefaults* defaults = NitroDiskDefaults();
     NSDictionary<NSString*, id>* entries = [defaults persistentDomainForName:kDiskSuiteName] ?: @{};
+    // Capture the registry before clearing the suite domain, which removes it.
+    NSMutableSet* legacyKeys = [registeredLegacyDiskKeys() mutableCopy];
     for (NSString* key in entries) {
         [defaults removeObjectForKey:key];
     }
+    // Clear the standard-defaults copies of every storage-owned key so legacy
+    // values deleted here cannot reappear through the read-time migration path.
+    NSUserDefaults* standard = [NSUserDefaults standardUserDefaults];
+    for (NSString* key in entries) {
+        if ([standard objectForKey:key] != nil) {
+            [standard removeObjectForKey:key];
+            [legacyKeys removeObject:key];
+        }
+    }
+    for (NSString* key in legacyKeys) {
+        if ([standard objectForKey:key] != nil) {
+            [standard removeObjectForKey:key];
+        }
+    }
+    [defaults removeObjectForKey:kLegacyDiskKeysRegistryKey];
 }
 
 // --- Secure (Keychain) ---
@@ -228,9 +325,7 @@ static void setSecureValue(
                 "The item is not accessible until the device is unlocked."
             );
         }
-        throw std::runtime_error(
-            "NitroStorage: Secure set failed with status " + std::to_string(addStatus)
-        );
+        throw keychainStatusError(addStatus, "Secure set");
     }
 
     if (status == errSecInteractionNotAllowed) {
@@ -240,9 +335,7 @@ static void setSecureValue(
             "The item is not accessible until the device is unlocked."
         );
     }
-    throw std::runtime_error(
-        "NitroStorage: Secure set failed with status " + std::to_string(status)
-    );
+    throw keychainStatusError(status, "Secure set");
 }
 
 static std::optional<std::string> getSecureValue(NSString* nsKey, NSString* group) {
@@ -290,6 +383,20 @@ static void deleteSecureValue(NSString* nsKey, NSString* group) {
     }
 }
 
+// Deletes only the plain (non-biometric) keychain copy. Promotion to biometric
+// storage must remove the plain copy so stale plain reads cannot resurrect it.
+static void deletePlainSecureValue(NSString* nsKey, NSString* group) {
+    NSMutableDictionary* secureQuery = baseKeychainQuery(nsKey, kKeychainService, group);
+    OSStatus secureStatus = SecItemDelete((__bridge CFDictionaryRef)secureQuery);
+    if (secureStatus == errSecInteractionNotAllowed) {
+        throw taggedStorageError(
+            "keychain_locked",
+            "NitroStorage: Keychain is locked (errSecInteractionNotAllowed). "
+            "The item is not accessible until the device is unlocked."
+        );
+    }
+}
+
 static std::vector<std::string> keychainAccountsForService(NSString* service, NSString* accessGroup) {
     NSMutableDictionary* query = allAccountsQuery(service, accessGroup);
     disableKeychainInteraction(query);
@@ -490,8 +597,7 @@ void IOSStorageAdapterCpp::clearSecure() {
                 "NitroStorage: Cannot clear secure storage: keychain is locked (errSecInteractionNotAllowed)"
             );
         }
-        throw std::runtime_error(
-            std::string("NitroStorage: clearSecure failed with status ") + std::to_string(secStatus));
+        throw keychainStatusError(secStatus, "clearSecure");
     }
 
     NSMutableDictionary* biometricQuery = [@{
@@ -509,8 +615,7 @@ void IOSStorageAdapterCpp::clearSecure() {
                 "NitroStorage: Cannot clear biometric storage: keychain is locked (errSecInteractionNotAllowed)"
             );
         }
-        throw std::runtime_error(
-            std::string("NitroStorage: clearSecureBiometric failed with status ") + std::to_string(bioStatus));
+        throw keychainStatusError(bioStatus, "clearSecureBiometric");
     }
     clearSecureKeyCache();  // Only clears cache AFTER confirmed deletion
 }
@@ -627,12 +732,52 @@ void IOSStorageAdapterCpp::setSecureBiometricWithLevel(const std::string& key, c
                 "The item is not accessible until the device is unlocked."
             );
         }
-        throw std::runtime_error(
+        if (addStatus == errSecNotAvailable) {
+            throw taggedStorageError(
+                "keychain_locked",
+                "NitroStorage: Biometric set failed: keychain is unavailable until the device is unlocked (errSecNotAvailable)."
+            );
+        }
+        throw taggedStorageError(
+            "biometric_unavailable",
             std::string("NitroStorage: Biometric set failed with status ") +
             std::to_string(addStatus) +
             (backup.has_value() ? " (previous value restored to non-biometric keychain)" : " (no previous value)"));
     }
+
+    // Promotion contract: the plain secure copy must not survive a biometric
+    // write, or plain reads would return a stale value (Android removes it too).
+    // If removing the plain copy fails after the biometric write succeeded,
+    // roll the biometric write back so the promotion either fully succeeds or
+    // leaves the previous state intact, then rethrow the original error.
+    try {
+        deletePlainSecureValue(nsKey, group);
+    } catch (const std::exception& plainDeleteError) {
+        if (backup.has_value()) {
+            CFErrorRef restoreError = NULL;
+            SecAccessControlRef restoreAccess = SecAccessControlCreateWithFlags(
+                kCFAllocatorDefault,
+                kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly,
+                flags,
+                &restoreError
+            );
+            if (restoreAccess && !restoreError) {
+                NSMutableDictionary* restoreQuery = baseKeychainQuery(nsKey, kBiometricKeychainService, group);
+                restoreQuery[(__bridge id)kSecValueData] = [nsStringFromStdString(*backup) dataUsingEncoding:NSUTF8StringEncoding];
+                restoreQuery[(__bridge id)kSecAttrAccessControl] = (__bridge_transfer id)restoreAccess;
+                SecItemAdd((__bridge CFDictionaryRef)restoreQuery, NULL);
+            } else {
+                if (restoreError) CFRelease(restoreError);
+                if (restoreAccess) CFRelease(restoreAccess);
+            }
+        } else {
+            NSMutableDictionary* rollbackQuery = baseKeychainQuery(nsKey, kBiometricKeychainService, group);
+            SecItemDelete((__bridge CFDictionaryRef)rollbackQuery);
+        }
+        throw;
+    }
     markBiometricKeySet(key);
+    markSecureKeyRemoved(key);
 }
 
 std::optional<std::string> IOSStorageAdapterCpp::getSecureBiometric(const std::string& key) {

package/lib/commonjs/capabilities.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveNativeWriteBuffering = resolveNativeWriteBuffering;
+exports.resolveWebWriteBuffering = resolveWebWriteBuffering;
+function resolveWebWriteBuffering(diskBackendName, secureBackendName) {
+  return {
+    disk: isIndexedDBWebBackendByName(diskBackendName),
+    secure: isIndexedDBWebBackendByName(secureBackendName)
+  };
+}
+function isIndexedDBWebBackendByName(backendName) {
+  if (!backendName) {
+    return false;
+  }
+  return backendName.startsWith("indexeddb:");
+}
+function resolveNativeWriteBuffering(platform, secureWritesAsync) {
+  return {
+    disk: true,
+    secure: platform === "android" ? secureWritesAsync : false
+  };
+}
+//# sourceMappingURL=capabilities.js.map

package/lib/commonjs/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["resolveWebWriteBuffering","diskBackendName","secureBackendName","disk","isIndexedDBWebBackendByName","secure","backendName","startsWith","resolveNativeWriteBuffering","platform","secureWritesAsync"],"sourceRoot":"../../src","sources":["capabilities.ts"],"mappings":";;;;;;;AAUO,SAASA,wBAAwBA,CACtCC,eAAmC,EACnCC,iBAAqC,EACrB;EAChB,OAAO;IACLC,IAAI,EAAEC,2BAA2B,CAACH,eAAe,CAAC;IAClDI,MAAM,EAAED,2BAA2B,CAACF,iBAAiB;EACvD,CAAC;AACH;AAEA,SAASE,2BAA2BA,CAACE,WAA+B,EAAW;EAC7E,IAAI,CAACA,WAAW,EAAE;IAChB,OAAO,KAAK;EACd;EACA,OAAOA,WAAW,CAACC,UAAU,CAAC,YAAY,CAAC;AAC7C;AAEO,SAASC,2BAA2BA,CACzCC,QAA2B,EAC3BC,iBAA0B,EACV;EAChB,OAAO;IACLP,IAAI,EAAE,IAAI;IACVE,MAAM,EAAEI,QAAQ,KAAK,SAAS,GAAGC,iBAAiB,GAAG;EACvD,CAAC;AACH","ignoreList":[]}

package/lib/commonjs/core/durability.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDurabilityCoordinator = createDurabilityCoordinator;
+var _shared = require("../shared");
+var _Storage = require("../Storage.types");
+function createDurabilityCoordinator(options) {
+  const pendingDiskWrites = new Map();
+  let diskFlushScheduled = false;
+  let diskWritesAsync = false;
+  const pendingSecureWrites = new Map();
+  let secureFlushScheduled = false;
+  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) {
+      options.backend.setBatch(keysToSet, valuesToSet, _Storage.StorageScope.Disk);
+    }
+    if (keysToRemove.length > 0) {
+      options.backend.removeBatch(keysToRemove, _Storage.StorageScope.Disk);
+    }
+  }
+  function flushSecureWrites() {
+    secureFlushScheduled = false;
+    if (pendingSecureWrites.size === 0) {
+      return;
+    }
+    const writes = Array.from(pendingSecureWrites.values());
+    pendingSecureWrites.clear();
+    const groupedSetWrites = new Map();
+    const keysToRemove = [];
+    writes.forEach(({
+      key,
+      value,
+      accessControl
+    }) => {
+      if (value === undefined) {
+        keysToRemove.push(key);
+      } else {
+        const resolvedAccessControl = accessControl ?? options.resolveSecureDefaultAccessControl();
+        const existingGroup = groupedSetWrites.get(resolvedAccessControl);
+        const group = existingGroup ?? {
+          keys: [],
+          values: []
+        };
+        group.keys.push(key);
+        group.values.push(value);
+        if (!existingGroup) {
+          groupedSetWrites.set(resolvedAccessControl, group);
+        }
+      }
+    });
+    groupedSetWrites.forEach((group, accessControl) => {
+      options.backend.setSecureAccessControl(accessControl);
+      options.backend.setBatch(group.keys, group.values, _Storage.StorageScope.Secure);
+    });
+    if (keysToRemove.length > 0) {
+      options.backend.removeBatch(keysToRemove, _Storage.StorageScope.Secure);
+    }
+  }
+  function scheduleDiskWrite(key, value) {
+    pendingDiskWrites.set(key, {
+      key,
+      value
+    });
+    if (diskFlushScheduled) {
+      return;
+    }
+    diskFlushScheduled = true;
+    (0, _shared.runMicrotask)(flushDiskWrites);
+  }
+  function scheduleSecureWrite(key, value, accessControl) {
+    const pendingWrite = {
+      key,
+      value
+    };
+    if (accessControl !== undefined) {
+      pendingWrite.accessControl = accessControl;
+    }
+    pendingSecureWrites.set(key, pendingWrite);
+    if (secureFlushScheduled) {
+      return;
+    }
+    secureFlushScheduled = true;
+    (0, _shared.runMicrotask)(flushSecureWrites);
+  }
+  return {
+    setDiskWritesAsync(enabled) {
+      diskWritesAsync = enabled;
+      if (!enabled) {
+        flushDiskWrites();
+      }
+    },
+    isDiskWritesAsync: () => diskWritesAsync,
+    hasPendingDiskWrite: key => pendingDiskWrites.has(key),
+    hasPendingSecureWrite: key => pendingSecureWrites.has(key),
+    readPendingDiskWrite: key => pendingDiskWrites.get(key)?.value,
+    readPendingSecureWrite: key => pendingSecureWrites.get(key)?.value,
+    clearPendingDiskWrite: key => {
+      pendingDiskWrites.delete(key);
+    },
+    clearPendingSecureWrite: key => {
+      pendingSecureWrites.delete(key);
+    },
+    clearAllPendingDiskWrites: () => {
+      pendingDiskWrites.clear();
+    },
+    clearAllPendingSecureWrites: () => {
+      pendingSecureWrites.clear();
+    },
+    scheduleDiskWrite,
+    scheduleSecureWrite,
+    flushDiskWrites,
+    flushSecureWrites
+  };
+}
+//# sourceMappingURL=durability.js.map

package/lib/commonjs/core/durability.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_shared","require","_Storage","createDurabilityCoordinator","options","pendingDiskWrites","Map","diskFlushScheduled","diskWritesAsync","pendingSecureWrites","secureFlushScheduled","flushDiskWrites","size","writes","Array","from","values","clear","keysToSet","valuesToSet","keysToRemove","forEach","key","value","undefined","push","length","backend","setBatch","StorageScope","Disk","removeBatch","flushSecureWrites","groupedSetWrites","accessControl","resolvedAccessControl","resolveSecureDefaultAccessControl","existingGroup","get","group","keys","set","setSecureAccessControl","Secure","scheduleDiskWrite","runMicrotask","scheduleSecureWrite","pendingWrite","setDiskWritesAsync","enabled","isDiskWritesAsync","hasPendingDiskWrite","has","hasPendingSecureWrite","readPendingDiskWrite","readPendingSecureWrite","clearPendingDiskWrite","delete","clearPendingSecureWrite","clearAllPendingDiskWrites","clearAllPendingSecureWrites"],"sourceRoot":"../../../src","sources":["core/durability.ts"],"mappings":"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","ignoreList":[]}