react-native-nitro-storage 0.7.0 → 0.9.0

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":[]}

package/lib/commonjs/core/metrics.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMetricsRegistry = createMetricsRegistry;
+var _shared = require("../shared");
+function createMetricsRegistry() {
+  let observer;
+  const counters = new Map();
+  function record(operation, scope, durationMs, keysCount = 1) {
+    const counterKey = `${operation}:${scope}`;
+    const existing = counters.get(counterKey);
+    if (!existing) {
+      counters.set(counterKey, {
+        count: 1,
+        totalDurationMs: durationMs,
+        maxDurationMs: durationMs
+      });
+    } else {
+      existing.count += 1;
+      existing.totalDurationMs += durationMs;
+      existing.maxDurationMs = Math.max(existing.maxDurationMs, durationMs);
+    }
+    observer?.({
+      operation,
+      scope,
+      durationMs,
+      keysCount
+    });
+  }
+  function measure(operation, scope, fn, keysCount = 1) {
+    if (!observer) {
+      return fn();
+    }
+    const start = (0, _shared.now)();
+    try {
+      return fn();
+    } finally {
+      record(operation, scope, (0, _shared.now)() - start, keysCount);
+    }
+  }
+  function toSummary(value) {
+    return {
+      count: value.count,
+      totalDurationMs: value.totalDurationMs,
+      avgDurationMs: value.count === 0 ? 0 : value.totalDurationMs / value.count,
+      maxDurationMs: value.maxDurationMs
+    };
+  }
+  return {
+    setObserver(next) {
+      observer = next;
+    },
+    record,
+    measure,
+    getSnapshot() {
+      const aggregated = new Map();
+      counters.forEach((value, key) => {
+        const separator = key.lastIndexOf(":");
+        const operation = separator === -1 ? key : key.slice(0, separator);
+        const existing = aggregated.get(operation);
+        if (!existing) {
+          aggregated.set(operation, {
+            ...value
+          });
+          return;
+        }
+        existing.count += value.count;
+        existing.totalDurationMs += value.totalDurationMs;
+        existing.maxDurationMs = Math.max(existing.maxDurationMs, value.maxDurationMs);
+      });
+      const snapshot = {};
+      aggregated.forEach((value, operation) => {
+        snapshot[operation] = toSummary(value);
+      });
+      return snapshot;
+    },
+    getScopedSnapshot() {
+      const snapshot = {};
+      counters.forEach((value, key) => {
+        snapshot[key] = toSummary(value);
+      });
+      return snapshot;
+    },
+    reset() {
+      counters.clear();
+    }
+  };
+}
+//# sourceMappingURL=metrics.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_shared","require","createMetricsRegistry","observer","counters","Map","record","operation","scope","durationMs","keysCount","counterKey","existing","get","set","count","totalDurationMs","maxDurationMs","Math","max","measure","fn","start","now","toSummary","value","avgDurationMs","setObserver","next","getSnapshot","aggregated","forEach","key","separator","lastIndexOf","slice","snapshot","getScopedSnapshot","reset","clear"],"sourceRoot":"../../../src","sources":["core/metrics.ts"],"mappings":"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","ignoreList":[]}