react-native-mmkv 4.3.1 → 4.3.2

package/android/build.gradle

@@ -5,7 +5,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:9.1.0"
+    classpath "com.android.tools.build:gradle:9.2.1"
   }
 }
 
@@ -36,14 +36,14 @@ def getExtOrIntegerDefault(name) {
 }
 
 android {
-  namespace "com.margelo.nitro.mmkv"
+  namespace = "com.margelo.nitro.mmkv"
 
-  ndkVersion getExtOrDefault("ndkVersion")
-  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+  ndkVersion = getExtOrDefault("ndkVersion")
+  compileSdkVersion = getExtOrIntegerDefault("compileSdkVersion")
 
   defaultConfig {
-    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
-    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    minSdkVersion = getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion = getExtOrIntegerDefault("targetSdkVersion")
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
 
     externalNativeBuild {
@@ -71,7 +71,7 @@ android {
 
   externalNativeBuild {
     cmake {
-      path "CMakeLists.txt"
+      path = file("CMakeLists.txt")
     }
   }
 
@@ -98,13 +98,13 @@ android {
   }
 
   buildFeatures {
-    buildConfig true
-    prefab true
+    buildConfig = true
+    prefab = true
   }
 
   buildTypes {
     release {
-      minifyEnabled false
+      minifyEnabled = false
     }
   }
 
@@ -145,6 +145,5 @@ dependencies {
   implementation project(":react-native-nitro-modules")
 
   // Add a dependency on mmkv core (this ships a C++ prefab)
-  implementation "io.github.zhongwuzw:mmkv:2.4.0"
+  implementation "io.github.zhongwuzw:mmkv:2.4.1"
 }
-

package/android/gradle.properties

@@ -1,5 +1,5 @@
-NitroMmkv_kotlinVersion=2.1.20
+NitroMmkv_kotlinVersion=2.3.21
 NitroMmkv_minSdkVersion=23
 NitroMmkv_targetSdkVersion=36
 NitroMmkv_compileSdkVersion=36
-NitroMmkv_ndkVersion=27.1.12297006
+NitroMmkv_ndkVersion=29.0.14206865

package/cpp/HybridMMKV.cpp

@@ -29,7 +29,8 @@ HybridMMKV::HybridMMKV(const Configuration& config) : HybridObject(TAG) {
                         .aes256 = useAes256Encryption,
                         .cryptKey = encryptionKeyPtr,
                         .rootPath = rootPathPtr,
-                        .enableCompareBeforeSet = compareBeforeSet};
+                        .enableCompareBeforeSet = compareBeforeSet,
+                        .recover = getRecoveryStrategy(config)};
 
   bool hasEncryptionKey = encryptionKey.size() > 0;
   Logger::log(LogLevel::Info, TAG, "Creating MMKV instance \"%s\"... (Path: %s, Encrypted: %s)", config.id.c_str(), rootPath.c_str(),
@@ -82,6 +83,10 @@ double HybridMMKV::getByteSize() {
   return instance->actualSize();
 }
 
+size_t HybridMMKV::getExternalMemorySize() noexcept {
+  return instance != nullptr ? instance->actualSize() : 0;
+}
+
 bool HybridMMKV::getIsReadOnly() {
   return instance->isReadOnly();
 }
@@ -224,6 +229,10 @@ void HybridMMKV::trim() {
   instance->clearMemoryCache();
 }
 
+void HybridMMKV::checkContentChanged() {
+  instance->checkContentChanged();
+}
+
 Listener HybridMMKV::addOnValueChangedListener(const std::function<void(const std::string& /* key */)>& onValueChanged) {
   // Add listener
   auto mmkvID = instance->mmapID();
@@ -248,6 +257,20 @@ MMKVMode HybridMMKV::getMMKVMode(const Configuration& config) {
   throw std::runtime_error("Invalid MMKV Mode value!");
 }
 
+std::optional<MMKVRecoverStrategic> HybridMMKV::getRecoveryStrategy(const Configuration& config) {
+  if (!config.recoveryStrategy.has_value()) {
+    return std::nullopt;
+  }
+
+  switch (config.recoveryStrategy.value()) {
+    case RecoveryStrategy::DISCARD_ON_ERROR:
+      return MMKVRecoverStrategic::OnErrorDiscard;
+    case RecoveryStrategy::RECOVER_ON_ERROR:
+      return MMKVRecoverStrategic::OnErrorRecover;
+  }
+  throw std::runtime_error("Invalid MMKV RecoveryStrategy value!");
+}
+
 double HybridMMKV::importAllFrom(const std::shared_ptr<HybridMMKVSpec>& other) {
   auto hybridMMKV = std::dynamic_pointer_cast<HybridMMKV>(other);
   if (hybridMMKV == nullptr) [[unlikely]] {

package/cpp/HybridMMKV.hpp

@@ -41,11 +41,16 @@ public:
   void encrypt(const std::string& key, std::optional<EncryptionType> encryptionType) override;
   void decrypt() override;
   void trim() override;
+  void checkContentChanged() override;
   Listener addOnValueChangedListener(const std::function<void(const std::string& /* key */)>& onValueChanged) override;
   double importAllFrom(const std::shared_ptr<HybridMMKVSpec>& other) override;
 
+protected:
+  size_t getExternalMemorySize() noexcept override;
+
 private:
   static MMKVMode getMMKVMode(const Configuration& config);
+  static std::optional<MMKVRecoverStrategic> getRecoveryStrategy(const Configuration& config);
 
 private:
   MMKV* instance;

package/lib/__tests__/contentChangedListener.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/contentChangedListener.test.js

@@ -0,0 +1,46 @@
+import { AppState } from 'react-native';
+import { createMockMMKV } from '../createMMKV/createMockMMKV';
+import { addContentChangedListener } from '../addContentChangedListener/addContentChangedListener';
+function mockAppStateChangeListener() {
+    const listeners = new Set();
+    jest
+        .spyOn(AppState, 'addEventListener')
+        .mockImplementation((type, listener) => {
+        if (type === 'change') {
+            listeners.add(listener);
+        }
+        return {
+            remove: () => {
+                listeners.delete(listener);
+            },
+        };
+    });
+    return {
+        emit: (state) => {
+            listeners.forEach((listener) => listener(state));
+        },
+    };
+}
+afterEach(() => {
+    jest.clearAllMocks();
+    jest.restoreAllMocks();
+});
+test('content changed listener checks content when app becomes active', () => {
+    const appState = mockAppStateChangeListener();
+    const storage = createMockMMKV({ id: 'content-changed-listener-test' });
+    const checkContentChanged = jest.spyOn(storage, 'checkContentChanged');
+    addContentChangedListener(storage);
+    appState.emit('background');
+    expect(checkContentChanged).not.toHaveBeenCalled();
+    appState.emit('active');
+    expect(checkContentChanged).toHaveBeenCalledTimes(1);
+});
+test('content changed listener registers once per instance', () => {
+    mockAppStateChangeListener();
+    const storage = createMockMMKV({
+        id: 'content-changed-listener-once-test',
+    });
+    addContentChangedListener(storage);
+    addContentChangedListener(storage);
+    expect(AppState.addEventListener).toHaveBeenCalledTimes(1);
+});

package/lib/addContentChangedListener/addContentChangedListener.d.ts

@@ -0,0 +1,2 @@
+import type { MMKV } from '../specs/MMKV.nitro';
+export declare function addContentChangedListener(mmkv: MMKV): void;

package/lib/addContentChangedListener/addContentChangedListener.js

@@ -0,0 +1,27 @@
+import { AppState } from 'react-native';
+const registeredInstances = new WeakSet();
+export function addContentChangedListener(mmkv) {
+    if (registeredInstances.has(mmkv)) {
+        return;
+    }
+    registeredInstances.add(mmkv);
+    if (global.WeakRef != null && global.FinalizationRegistry != null) {
+        const weakMmkv = new WeakRef(mmkv);
+        const listener = AppState.addEventListener('change', (state) => {
+            if (state === 'active') {
+                weakMmkv.deref()?.checkContentChanged();
+            }
+        });
+        const finalization = new FinalizationRegistry((l) => {
+            l.remove();
+        });
+        finalization.register(mmkv, listener);
+    }
+    else {
+        AppState.addEventListener('change', (state) => {
+            if (state === 'active') {
+                mmkv.checkContentChanged();
+            }
+        });
+    }
+}

package/lib/addContentChangedListener/addContentChangedListener.mock.d.ts

@@ -0,0 +1,2 @@
+import type { MMKV } from '../specs/MMKV.nitro';
+export declare function addContentChangedListener(_mmkv: MMKV): void;

package/lib/addContentChangedListener/addContentChangedListener.mock.js

@@ -0,0 +1,3 @@
+export function addContentChangedListener(_mmkv) {
+    // no-op in mocked environments
+}

package/lib/addContentChangedListener/addContentChangedListener.web.d.ts

@@ -0,0 +1,2 @@
+import type { MMKV } from '../specs/MMKV.nitro';
+export declare function addContentChangedListener(_mmkv: MMKV): void;

package/lib/addContentChangedListener/addContentChangedListener.web.js

@@ -0,0 +1,3 @@
+export function addContentChangedListener(_mmkv) {
+    // no-op on Web
+}

package/lib/createMMKV/createMMKV.js

@@ -1,5 +1,6 @@
 import { Platform } from 'react-native';
 import { addMemoryWarningListener } from '../addMemoryWarningListener/addMemoryWarningListener';
+import { addContentChangedListener } from '../addContentChangedListener/addContentChangedListener';
 import { isTest } from '../isTest';
 import { createMockMMKV } from './createMockMMKV';
 import { getMMKVFactory, getPlatformContext } from '../getMMKVFactory';
@@ -26,5 +27,7 @@ export function createMMKV(configuration) {
     const mmkv = factory.createMMKV(config);
     // Add a hook that trims the storage when we get a memory warning
     addMemoryWarningListener(mmkv);
+    // Check for updates from app extensions/App Clips/background services when the app becomes active
+    addContentChangedListener(mmkv);
     return mmkv;
 }

package/lib/createMMKV/createMMKV.web.js

@@ -27,7 +27,8 @@ export function createMMKV(config = { id: 'mmkv.default' }) {
     return {
         id: config.id,
         get length() {
-            return getLocalStorage().length;
+            const keys = this.getAllKeys();
+            return keys.length;
         },
         get size() {
             return this.byteSize;
@@ -116,6 +117,9 @@ export function createMMKV(config = { id: 'mmkv.default' }) {
         trim: () => {
             // no-op
         },
+        checkContentChanged: () => {
+            // no-op
+        },
         dispose: () => { },
         equals: () => false,
         name: 'MMKV',

package/lib/createMMKV/createMockMMKV.js

@@ -74,6 +74,9 @@ export function createMockMMKV(config = { id: 'mmkv.default' }) {
         trim: () => {
             // no-op
         },
+        checkContentChanged: () => {
+            // no-op
+        },
         name: 'MMKV',
         dispose: () => { },
         equals: () => {

package/lib/hooks/useMMKV.js

@@ -5,9 +5,13 @@ function isConfigurationEqual(left, right) {
     if (left == null || right == null)
         return left == null && right == null;
     return (left.encryptionKey === right.encryptionKey &&
+        left.encryptionType === right.encryptionType &&
         left.id === right.id &&
         left.path === right.path &&
-        left.mode === right.mode);
+        left.mode === right.mode &&
+        left.readOnly === right.readOnly &&
+        left.compareBeforeSet === right.compareBeforeSet &&
+        left.recoveryStrategy === right.recoveryStrategy);
 }
 export function useMMKV(configuration) {
     const instance = useRef(undefined);

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export type { MMKV } from './specs/MMKV.nitro';
-export type { Configuration, Mode } from './specs/MMKVFactory.nitro';
+export type { Configuration, Mode, RecoveryStrategy, } from './specs/MMKVFactory.nitro';
 export { createMMKV } from './createMMKV/createMMKV';
 export { existsMMKV } from './existsMMKV/existsMMKV';
 export { deleteMMKV } from './deleteMMKV/deleteMMKV';

package/lib/specs/MMKV.nitro.d.ts

@@ -134,6 +134,11 @@ export interface MMKV extends HybridObject<{
      * In most applications, this is not needed at all.
      */
     trim(): void;
+    /**
+     * Checks whether the underlying storage file changed outside this process,
+     * and reloads this instance's data if needed.
+     */
+    checkContentChanged(): void;
     /**
      * Adds a value changed listener. The Listener will be called whenever any value
      * in this storage instance changes (set or delete).

package/lib/specs/MMKVFactory.nitro.d.ts

@@ -12,6 +12,12 @@ export type Mode = 'single-process' | 'multi-process';
  * - `AES-256`: Uses AES-256 encryption for enhanced security.
  */
 export type EncryptionType = 'AES-128' | 'AES-256';
+/**
+ * Configures how MMKV should handle recoverable storage errors.
+ * - `discard-on-error`: Discards data when MMKV detects a CRC or file-length error.
+ * - `recover-on-error`: Attempts to recover data when MMKV detects a CRC or file-length error.
+ */
+export type RecoveryStrategy = 'discard-on-error' | 'recover-on-error';
 /**
  * Used for configuration of a single MMKV instance.
  */
@@ -91,6 +97,12 @@ export interface Configuration {
      * @default false
      */
     compareBeforeSet?: boolean;
+    /**
+     * Configure how MMKV should handle recoverable storage errors.
+     *
+     * @default undefined
+     */
+    recoveryStrategy?: RecoveryStrategy;
 }
 export interface MMKVFactory extends HybridObject<{
     ios: 'c++';

package/nitro.json

@@ -14,11 +14,20 @@
   },
   "autolinking": {
     "MMKVFactory": {
-      "cpp": "HybridMMKVFactory"
+      "all": {
+        "language": "c++",
+        "implementationClassName": "HybridMMKVFactory"
+      }
     },
     "MMKVPlatformContext": {
-      "swift": "HybridMMKVPlatformContext",
-      "kotlin": "HybridMMKVPlatformContext"
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridMMKVPlatformContext"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HybridMMKVPlatformContext"
+      }
     }
   },
   "ignorePaths": [

package/nitrogen/generated/android/NitroMmkvOnLoad.cpp

@@ -28,9 +28,9 @@ int initialize(JavaVM* vm) {
 }
 
 struct JHybridMMKVPlatformContextSpecImpl: public jni::JavaClass<JHybridMMKVPlatformContextSpecImpl, JHybridMMKVPlatformContextSpec::JavaPart> {
-  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/mmkv/HybridMMKVPlatformContext;";
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/mmkv/HybridMMKVPlatformContext;";
   static std::shared_ptr<JHybridMMKVPlatformContextSpec> create() {
-    static auto constructorFn = javaClassStatic()->getConstructor<JHybridMMKVPlatformContextSpecImpl::javaobject()>();
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridMMKVPlatformContextSpecImpl::javaobject()>();
     jni::local_ref<JHybridMMKVPlatformContextSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
     return javaPart->getJHybridMMKVPlatformContextSpec();
   }

package/nitrogen/generated/android/c++/JHybridMMKVPlatformContextSpec.hpp

@@ -21,11 +21,11 @@ namespace margelo::nitro::mmkv {
   class JHybridMMKVPlatformContextSpec: public virtual HybridMMKVPlatformContextSpec, public virtual JHybridObject {
   public:
     struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
-      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/mmkv/HybridMMKVPlatformContextSpec;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/mmkv/HybridMMKVPlatformContextSpec;";
       std::shared_ptr<JHybridMMKVPlatformContextSpec> getJHybridMMKVPlatformContextSpec();
     };
     struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
-      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/mmkv/HybridMMKVPlatformContextSpec$CxxPart;";
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/mmkv/HybridMMKVPlatformContextSpec$CxxPart;";
       static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
       static void registerNatives();
       using HybridBase::HybridBase;

package/nitrogen/generated/ios/NitroMmkv+autolinking.rb

@@ -56,5 +56,7 @@ def add_nitrogen_files(spec)
     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
     # Enables stricter modular headers
     "DEFINES_MODULE" => "YES",
+    # Disable auto-generated ObjC header for Swift (Static linkage on Xcode 26.4 breaks here)
+    "SWIFT_INSTALL_OBJC_HEADER" => "NO",
   })
 end

package/nitrogen/generated/shared/c++/Configuration.hpp

@@ -32,11 +32,14 @@
 namespace margelo::nitro::mmkv { enum class EncryptionType; }
 // Forward declaration of `Mode` to properly resolve imports.
 namespace margelo::nitro::mmkv { enum class Mode; }
+// Forward declaration of `RecoveryStrategy` to properly resolve imports.
+namespace margelo::nitro::mmkv { enum class RecoveryStrategy; }
 
 #include <string>
 #include <optional>
 #include "EncryptionType.hpp"
 #include "Mode.hpp"
+#include "RecoveryStrategy.hpp"
 
 namespace margelo::nitro::mmkv {
 
@@ -52,10 +55,11 @@ namespace margelo::nitro::mmkv {
     std::optional<Mode> mode     SWIFT_PRIVATE;
     std::optional<bool> readOnly     SWIFT_PRIVATE;
     std::optional<bool> compareBeforeSet     SWIFT_PRIVATE;
+    std::optional<RecoveryStrategy> recoveryStrategy     SWIFT_PRIVATE;
 
   public:
     Configuration() = default;
-    explicit Configuration(std::string id, std::optional<std::string> path, std::optional<std::string> encryptionKey, std::optional<EncryptionType> encryptionType, std::optional<Mode> mode, std::optional<bool> readOnly, std::optional<bool> compareBeforeSet): id(id), path(path), encryptionKey(encryptionKey), encryptionType(encryptionType), mode(mode), readOnly(readOnly), compareBeforeSet(compareBeforeSet) {}
+    explicit Configuration(std::string id, std::optional<std::string> path, std::optional<std::string> encryptionKey, std::optional<EncryptionType> encryptionType, std::optional<Mode> mode, std::optional<bool> readOnly, std::optional<bool> compareBeforeSet, std::optional<RecoveryStrategy> recoveryStrategy): id(id), path(path), encryptionKey(encryptionKey), encryptionType(encryptionType), mode(mode), readOnly(readOnly), compareBeforeSet(compareBeforeSet), recoveryStrategy(recoveryStrategy) {}
 
   public:
     friend bool operator==(const Configuration& lhs, const Configuration& rhs) = default;
@@ -77,7 +81,8 @@ namespace margelo::nitro {
         JSIConverter<std::optional<margelo::nitro::mmkv::EncryptionType>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "encryptionType"))),
         JSIConverter<std::optional<margelo::nitro::mmkv::Mode>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mode"))),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "readOnly"))),
-        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "compareBeforeSet")))
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "compareBeforeSet"))),
+        JSIConverter<std::optional<margelo::nitro::mmkv::RecoveryStrategy>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "recoveryStrategy")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::mmkv::Configuration& arg) {
@@ -89,6 +94,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "mode"), JSIConverter<std::optional<margelo::nitro::mmkv::Mode>>::toJSI(runtime, arg.mode));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "readOnly"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.readOnly));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "compareBeforeSet"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.compareBeforeSet));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "recoveryStrategy"), JSIConverter<std::optional<margelo::nitro::mmkv::RecoveryStrategy>>::toJSI(runtime, arg.recoveryStrategy));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -106,6 +112,7 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<margelo::nitro::mmkv::Mode>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "mode")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "readOnly")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "compareBeforeSet")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::mmkv::RecoveryStrategy>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "recoveryStrategy")))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/HybridMMKVSpec.cpp

@@ -33,6 +33,7 @@ namespace margelo::nitro::mmkv {
       prototype.registerHybridMethod("encrypt", &HybridMMKVSpec::encrypt);
       prototype.registerHybridMethod("decrypt", &HybridMMKVSpec::decrypt);
       prototype.registerHybridMethod("trim", &HybridMMKVSpec::trim);
+      prototype.registerHybridMethod("checkContentChanged", &HybridMMKVSpec::checkContentChanged);
       prototype.registerHybridMethod("addOnValueChangedListener", &HybridMMKVSpec::addOnValueChangedListener);
       prototype.registerHybridMethod("importAllFrom", &HybridMMKVSpec::importAllFrom);
     });

package/nitrogen/generated/shared/c++/HybridMMKVSpec.hpp

@@ -80,6 +80,7 @@ namespace margelo::nitro::mmkv {
       virtual void encrypt(const std::string& key, std::optional<EncryptionType> encryptionType) = 0;
       virtual void decrypt() = 0;
       virtual void trim() = 0;
+      virtual void checkContentChanged() = 0;
       virtual Listener addOnValueChangedListener(const std::function<void(const std::string& /* key */)>& onValueChanged) = 0;
       virtual double importAllFrom(const std::shared_ptr<HybridMMKVSpec>& other) = 0;
 

package/nitrogen/generated/shared/c++/RecoveryStrategy.hpp

@@ -0,0 +1,76 @@
+///
+/// RecoveryStrategy.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::mmkv {
+
+  /**
+   * An enum which can be represented as a JavaScript union (RecoveryStrategy).
+   */
+  enum class RecoveryStrategy {
+    DISCARD_ON_ERROR      SWIFT_NAME(discardOnError) = 0,
+    RECOVER_ON_ERROR      SWIFT_NAME(recoverOnError) = 1,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::mmkv
+
+namespace margelo::nitro {
+
+  // C++ RecoveryStrategy <> JS RecoveryStrategy (union)
+  template <>
+  struct JSIConverter<margelo::nitro::mmkv::RecoveryStrategy> final {
+    static inline margelo::nitro::mmkv::RecoveryStrategy fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("discard-on-error"): return margelo::nitro::mmkv::RecoveryStrategy::DISCARD_ON_ERROR;
+        case hashString("recover-on-error"): return margelo::nitro::mmkv::RecoveryStrategy::RECOVER_ON_ERROR;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum RecoveryStrategy - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::mmkv::RecoveryStrategy arg) {
+      switch (arg) {
+        case margelo::nitro::mmkv::RecoveryStrategy::DISCARD_ON_ERROR: return JSIConverter<std::string>::toJSI(runtime, "discard-on-error");
+        case margelo::nitro::mmkv::RecoveryStrategy::RECOVER_ON_ERROR: return JSIConverter<std::string>::toJSI(runtime, "recover-on-error");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert RecoveryStrategy to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("discard-on-error"):
+        case hashString("recover-on-error"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mmkv",
-  "version": "4.3.1",
+  "version": "4.3.2",
   "description": "⚡️ The fastest key/value storage for React Native.",
   "main": "lib/index",
   "module": "lib/index",
@@ -33,8 +33,8 @@
   "scripts": {
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf android/build node_modules/**/android/build lib",
-    "lint": "eslint \"**/*.{js,ts,tsx}\" --fix",
-    "lint-ci": "eslint \"**/*.{js,ts,tsx}\" -f @jamesacarr/github-actions",
+    "lint": "eslint \"**/*.{js,ts,tsx}\" --fix && prettier --write \"**/*.{js,ts,tsx}\"",
+    "lint-ci": "eslint \"**/*.{js,ts,tsx}\" --max-warnings=0 -f @jamesacarr/github-actions && prettier --check \"**/*.{js,ts,tsx}\"",
     "typescript": "tsc",
     "specs": "tsc && nitrogen --logLevel=\"debug\"",
     "build": "tsc --noEmit false",
@@ -59,20 +59,19 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@expo/config-plugins": "^10.1.2",
-    "@react-native/eslint-config": "0.82.0",
+    "@react-native/eslint-config": "0.85.3",
+    "@react-native/jest-preset": "0.85.3",
     "@testing-library/react-native": "^13.3.1",
-    "@types/jest": "^29.5.12",
-    "@types/react": "^19.0.6",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-prettier": "^5.2.1",
-    "nitrogen": "0.35.0",
-    "prettier": "^3.3.3",
-    "react": "19.1.1",
-    "react-native": "0.82.0",
-    "react-native-nitro-modules": "0.35.0",
-    "typescript": "^5.8.3"
+    "@types/jest": "^29.5.14",
+    "@types/react": "^19.2.15",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^10.1.8",
+    "nitrogen": "0.35.9",
+    "prettier": "^3.8.3",
+    "react": "19.2.6",
+    "react-native": "0.85.3",
+    "react-native-nitro-modules": "0.35.9",
+    "typescript": "^6.0.3"
   },
   "peerDependencies": {
     "react": "*",
@@ -84,22 +83,7 @@
     "extends": [
       "@react-native",
       "prettier"
-    ],
-    "plugins": [
-      "prettier"
-    ],
-    "rules": {
-      "prettier/prettier": [
-        "warn",
-        {
-          "quoteProps": "consistent",
-          "singleQuote": true,
-          "tabWidth": 2,
-          "trailingComma": "es5",
-          "useTabs": false
-        }
-      ]
-    }
+    ]
   },
   "eslintIgnore": [
     "node_modules/",

package/src/__tests__/contentChangedListener.test.ts

@@ -0,0 +1,61 @@
+import { AppState } from 'react-native'
+import type { AppStateStatus, NativeEventSubscription } from 'react-native'
+import { createMockMMKV } from '../createMMKV/createMockMMKV'
+import { addContentChangedListener } from '../addContentChangedListener/addContentChangedListener'
+
+function mockAppStateChangeListener(): {
+  emit: (state: AppStateStatus) => void
+} {
+  const listeners = new Set<(state: AppStateStatus) => void>()
+
+  jest
+    .spyOn(AppState, 'addEventListener')
+    .mockImplementation((type, listener): NativeEventSubscription => {
+      if (type === 'change') {
+        listeners.add(listener as (state: AppStateStatus) => void)
+      }
+
+      return {
+        remove: () => {
+          listeners.delete(listener as (state: AppStateStatus) => void)
+        },
+      } as NativeEventSubscription
+    })
+
+  return {
+    emit: (state) => {
+      listeners.forEach((listener) => listener(state))
+    },
+  }
+}
+
+afterEach(() => {
+  jest.clearAllMocks()
+  jest.restoreAllMocks()
+})
+
+test('content changed listener checks content when app becomes active', () => {
+  const appState = mockAppStateChangeListener()
+  const storage = createMockMMKV({ id: 'content-changed-listener-test' })
+  const checkContentChanged = jest.spyOn(storage, 'checkContentChanged')
+
+  addContentChangedListener(storage)
+
+  appState.emit('background')
+  expect(checkContentChanged).not.toHaveBeenCalled()
+
+  appState.emit('active')
+  expect(checkContentChanged).toHaveBeenCalledTimes(1)
+})
+
+test('content changed listener registers once per instance', () => {
+  mockAppStateChangeListener()
+  const storage = createMockMMKV({
+    id: 'content-changed-listener-once-test',
+  })
+
+  addContentChangedListener(storage)
+  addContentChangedListener(storage)
+
+  expect(AppState.addEventListener).toHaveBeenCalledTimes(1)
+})

package/src/addContentChangedListener/addContentChangedListener.mock.ts

@@ -0,0 +1,5 @@
+import type { MMKV } from '../specs/MMKV.nitro'
+
+export function addContentChangedListener(_mmkv: MMKV): void {
+  // no-op in mocked environments
+}

package/src/addContentChangedListener/addContentChangedListener.ts

@@ -0,0 +1,36 @@
+import { AppState } from 'react-native'
+import type { AppStateStatus, NativeEventSubscription } from 'react-native'
+import type { MMKV } from '../specs/MMKV.nitro'
+
+const registeredInstances = new WeakSet<MMKV>()
+
+export function addContentChangedListener(mmkv: MMKV): void {
+  if (registeredInstances.has(mmkv)) {
+    return
+  }
+  registeredInstances.add(mmkv)
+
+  if (global.WeakRef != null && global.FinalizationRegistry != null) {
+    const weakMmkv = new WeakRef(mmkv)
+    const listener = AppState.addEventListener(
+      'change',
+      (state: AppStateStatus) => {
+        if (state === 'active') {
+          weakMmkv.deref()?.checkContentChanged()
+        }
+      }
+    )
+    const finalization = new FinalizationRegistry(
+      (l: NativeEventSubscription) => {
+        l.remove()
+      }
+    )
+    finalization.register(mmkv, listener)
+  } else {
+    AppState.addEventListener('change', (state: AppStateStatus) => {
+      if (state === 'active') {
+        mmkv.checkContentChanged()
+      }
+    })
+  }
+}

package/src/addContentChangedListener/addContentChangedListener.web.ts

@@ -0,0 +1,5 @@
+import type { MMKV } from '../specs/MMKV.nitro'
+
+export function addContentChangedListener(_mmkv: MMKV): void {
+  // no-op on Web
+}

package/src/createMMKV/createMMKV.ts

@@ -2,6 +2,7 @@ import type { MMKV } from '../specs/MMKV.nitro'
 import type { Configuration } from '../specs/MMKVFactory.nitro'
 import { Platform } from 'react-native'
 import { addMemoryWarningListener } from '../addMemoryWarningListener/addMemoryWarningListener'
+import { addContentChangedListener } from '../addContentChangedListener/addContentChangedListener'
 import { isTest } from '../isTest'
 import { createMockMMKV } from './createMockMMKV'
 import { getMMKVFactory, getPlatformContext } from '../getMMKVFactory'
@@ -33,5 +34,7 @@ export function createMMKV(configuration?: Configuration): MMKV {
   const mmkv = factory.createMMKV(config)
   // Add a hook that trims the storage when we get a memory warning
   addMemoryWarningListener(mmkv)
+  // Check for updates from app extensions/App Clips/background services when the app becomes active
+  addContentChangedListener(mmkv)
   return mmkv
 }

package/src/createMMKV/createMMKV.web.ts

@@ -42,7 +42,8 @@ export function createMMKV(
   return {
     id: config.id,
     get length(): number {
-      return getLocalStorage().length
+      const keys = this.getAllKeys()
+      return keys.length
     },
     get size(): number {
       return this.byteSize
@@ -125,6 +126,9 @@ export function createMMKV(
     trim: () => {
       // no-op
     },
+    checkContentChanged: () => {
+      // no-op
+    },
     dispose: () => {},
     equals: () => false,
     name: 'MMKV',

package/src/createMMKV/createMockMMKV.ts

@@ -80,6 +80,9 @@ export function createMockMMKV(
     trim: () => {
       // no-op
     },
+    checkContentChanged: () => {
+      // no-op
+    },
     name: 'MMKV',
     dispose: () => {},
     equals: () => {

package/src/hooks/useMMKV.ts

@@ -12,9 +12,13 @@ function isConfigurationEqual(
 
   return (
     left.encryptionKey === right.encryptionKey &&
+    left.encryptionType === right.encryptionType &&
     left.id === right.id &&
     left.path === right.path &&
-    left.mode === right.mode
+    left.mode === right.mode &&
+    left.readOnly === right.readOnly &&
+    left.compareBeforeSet === right.compareBeforeSet &&
+    left.recoveryStrategy === right.recoveryStrategy
   )
 }
 

package/src/index.ts

@@ -1,6 +1,10 @@
 // All types
 export type { MMKV } from './specs/MMKV.nitro'
-export type { Configuration, Mode } from './specs/MMKVFactory.nitro'
+export type {
+  Configuration,
+  Mode,
+  RecoveryStrategy,
+} from './specs/MMKVFactory.nitro'
 
 // The create function
 export { createMMKV } from './createMMKV/createMMKV'

package/src/specs/MMKV.nitro.ts

@@ -133,6 +133,11 @@ export interface MMKV extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
    * In most applications, this is not needed at all.
    */
   trim(): void
+  /**
+   * Checks whether the underlying storage file changed outside this process,
+   * and reloads this instance's data if needed.
+   */
+  checkContentChanged(): void
   /**
    * Adds a value changed listener. The Listener will be called whenever any value
    * in this storage instance changes (set or delete).

package/src/specs/MMKVFactory.nitro.ts

@@ -15,6 +15,13 @@ export type Mode = 'single-process' | 'multi-process'
  */
 export type EncryptionType = 'AES-128' | 'AES-256'
 
+/**
+ * Configures how MMKV should handle recoverable storage errors.
+ * - `discard-on-error`: Discards data when MMKV detects a CRC or file-length error.
+ * - `recover-on-error`: Attempts to recover data when MMKV detects a CRC or file-length error.
+ */
+export type RecoveryStrategy = 'discard-on-error' | 'recover-on-error'
+
 /**
  * Used for configuration of a single MMKV instance.
  */
@@ -94,10 +101,18 @@ export interface Configuration {
    * @default false
    */
   compareBeforeSet?: boolean
+  /**
+   * Configure how MMKV should handle recoverable storage errors.
+   *
+   * @default undefined
+   */
+  recoveryStrategy?: RecoveryStrategy
 }
 
-export interface MMKVFactory
-  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+export interface MMKVFactory extends HybridObject<{
+  ios: 'c++'
+  android: 'c++'
+}> {
   /**
    * Initialize the MMKV library with the given root path.
    * This has to be called once, before using {@linkcode createMMKV}.

package/src/specs/MMKVPlatformContext.nitro.ts

@@ -1,7 +1,9 @@
 import type { HybridObject } from 'react-native-nitro-modules'
 
-export interface MMKVPlatformContext
-  extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
+export interface MMKVPlatformContext extends HybridObject<{
+  ios: 'swift'
+  android: 'kotlin'
+}> {
   /**
    * Get the MMKV base directory
    */