@react-native-firebase/remote-config 26.3.3 → 26.4.0

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [26.4.0](https://github.com/invertase/react-native-firebase/compare/v26.3.3...v26.4.0) (2026-09-05)
+
+### Bug Fixes
+
+- **remote-config:** use RNFBHandleMap for config update handlers ([f142bdb](https://github.com/invertase/react-native-firebase/commit/f142bdb1d9ec9318c5587a6f70e6cd6da28e9797))
+
 ## [26.3.3](https://github.com/invertase/react-native-firebase/compare/v26.3.2...v26.3.3) (2026-09-01)
 
 ### Bug Fixes

package/RNFBRemoteConfig.podspec

@@ -31,7 +31,7 @@ Pod::Spec.new do |s|
   s.tvos.deployment_target = firebase_tvos_target
   s.source_files        = 'ios/**/*.{h,m,mm,cpp}'
   s.private_header_files = "ios/**/*.h"
-  s.exclude_files       = 'ios/generated/RCTThirdPartyComponentsProvider.*', 'ios/generated/RCTAppDependencyProvider.*', 'ios/generated/RCTModuleProviders.*', 'ios/generated/RCTModulesConformingToProtocolsProvider.*', 'ios/generated/RCTUnstableModulesRequiringMainQueueSetupProvider.*'
+  s.exclude_files       = 'ios/generated/RCTThirdPartyComponentsProvider.*', 'ios/generated/RCTAppDependencyProvider.*', 'ios/generated/RCTModuleProviders.*', 'ios/generated/RCTModulesConformingToProtocolsProvider.*', 'ios/generated/RCTUnstableModulesRequiringMainQueueSetupProvider.*', 'ios/*UnitTests/**'
 
   # Must be set before install_modules_dependencies so RN can append use_frameworks
   # HEADER_SEARCH_PATHS (React-debug etc.). Assigning after overwrites those paths

package/android/build.gradle

@@ -93,6 +93,8 @@ dependencies {
   api appProject
   implementation platform("com.google.firebase:firebase-bom:${ReactNative.ext.getVersion("firebase", "bom")}")
   implementation "com.google.firebase:firebase-config"
+
+  testImplementation "junit:junit:4.13.2"
 }
 
 ReactNative.shared.applyPackageVersion()

package/android/src/main/java/io/invertase/firebase/config/ConfigUpdateListenerHandle.java

@@ -0,0 +1,26 @@
+package io.invertase.firebase.config;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/**
+ * Detach surface stored in {@link RNFBRemoteConfigListenerRegistry}. Invoked after {@code get}/
+ * {@code take}/{@code takeAll}, never under the HandleMap lock.
+ */
+interface ConfigUpdateListenerHandle {
+  void remove();
+}

package/android/src/main/java/io/invertase/firebase/config/RNFBRemoteConfigListenerRegistry.java

@@ -0,0 +1,76 @@
+package io.invertase.firebase.config;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import io.invertase.firebase.common.RNFBHandleCollisionException;
+import io.invertase.firebase.common.RNFBHandleMap;
+import java.util.List;
+
+/**
+ * Remote Config update-listener map. Unique {@link #put} / {@link #putOrDiscard}; callers {@link
+ * #take} or {@link #takeAllAndRemove} then {@code remove()} outside the HandleMap lock.
+ * Skip-if-registered is {@code get(appName) != null}.
+ */
+final class RNFBRemoteConfigListenerRegistry {
+  private final RNFBHandleMap<String, ConfigUpdateListenerHandle> map = new RNFBHandleMap<>();
+
+  void put(String appName, ConfigUpdateListenerHandle handle) throws RNFBHandleCollisionException {
+    map.put(appName, handle);
+  }
+
+  /**
+   * Unique put. On collision, {@code remove()} the incoming handle and leave the existing mapping.
+   *
+   * @return true if stored
+   */
+  boolean putOrDiscard(String appName, ConfigUpdateListenerHandle handle) {
+    try {
+      map.put(appName, handle);
+      return true;
+    } catch (RNFBHandleCollisionException collision) {
+      if (handle != null) {
+        handle.remove();
+      }
+      return false;
+    }
+  }
+
+  ConfigUpdateListenerHandle get(String appName) {
+    return map.get(appName);
+  }
+
+  ConfigUpdateListenerHandle take(String appName) {
+    return map.take(appName);
+  }
+
+  void takeAndRemove(String appName) {
+    ConfigUpdateListenerHandle handle = map.take(appName);
+    if (handle != null) {
+      handle.remove();
+    }
+  }
+
+  void takeAllAndRemove() {
+    List<ConfigUpdateListenerHandle> remaining = map.takeAll();
+    for (ConfigUpdateListenerHandle handle : remaining) {
+      if (handle != null) {
+        handle.remove();
+      }
+    }
+  }
+}

package/android/src/reactnative/java/io/invertase/firebase/config/NativeRNFBTurboConfig.java

@@ -37,7 +37,6 @@ import io.invertase.firebase.common.ReactNativeFirebaseEvent;
 import io.invertase.firebase.common.ReactNativeFirebaseEventEmitter;
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -48,8 +47,8 @@ public class NativeRNFBTurboConfig extends NativeRNFBTurboConfigSpec {
   private static final String SERVICE_NAME = "Config";
   private final UniversalFirebaseConfigModule module;
 
-  private static final HashMap<String, ConfigUpdateListenerRegistration>
-      mConfigUpdateRegistrations = new HashMap<>();
+  private static final RNFBRemoteConfigListenerRegistry configUpdateListeners =
+      new RNFBRemoteConfigListenerRegistry();
 
   public NativeRNFBTurboConfig(ReactApplicationContext reactContext) {
     super(reactContext);
@@ -60,15 +59,7 @@ public class NativeRNFBTurboConfig extends NativeRNFBTurboConfigSpec {
   public void invalidate() {
     super.invalidate();
 
-    Iterator<Map.Entry<String, ConfigUpdateListenerRegistration>> configRegistrationsIterator =
-        mConfigUpdateRegistrations.entrySet().iterator();
-
-    while (configRegistrationsIterator.hasNext()) {
-      Map.Entry<String, ConfigUpdateListenerRegistration> pair = configRegistrationsIterator.next();
-      ConfigUpdateListenerRegistration mConfigRegistration = pair.getValue();
-      mConfigRegistration.remove();
-      configRegistrationsIterator.remove();
-    }
+    configUpdateListeners.takeAllAndRemove();
 
     module.onTearDown();
   }
@@ -198,79 +189,76 @@ public class NativeRNFBTurboConfig extends NativeRNFBTurboConfigSpec {
 
   @Override
   public void onConfigUpdated(String appName) {
-    if (mConfigUpdateRegistrations.get(appName) == null) {
-      ConfigUpdateListenerRegistration registration =
-          FirebaseRemoteConfig.getInstance(FirebaseApp.getInstance(appName))
-              .addOnConfigUpdateListener(
-                  new ConfigUpdateListener() {
-                    @Override
-                    public void onUpdate(@NotNull ConfigUpdate configUpdate) {
-                      ReactNativeFirebaseEventEmitter emitter =
-                          ReactNativeFirebaseEventEmitter.getSharedInstance();
-
-                      Set<String> updatedKeys = configUpdate.getUpdatedKeys();
-                      List<String> updatedKeysList = new ArrayList<>(updatedKeys);
-
-                      Map<String, Object> results = new HashMap<>();
-                      results.put("appName", appName);
-                      results.put("resultType", "success");
-                      results.put("updatedKeys", updatedKeysList);
-                      ReactNativeFirebaseEvent event =
-                          new ReactNativeFirebaseEvent(
-                              "on_config_updated", Arguments.makeNativeMap(results), appName);
-                      emitter.sendEvent(event);
-                    }
+    if (configUpdateListeners.get(appName) != null) {
+      return;
+    }
 
-                    @Override
-                    public void onError(@NotNull FirebaseRemoteConfigException error) {
-                      ReactNativeFirebaseEventEmitter emitter =
-                          ReactNativeFirebaseEventEmitter.getSharedInstance();
-
-                      WritableMap userInfoMap = Arguments.createMap();
-                      userInfoMap.putString("resultType", "error");
-                      userInfoMap.putString("appName", appName);
-
-                      FirebaseRemoteConfigException.Code code = error.getCode();
-                      switch (code) {
-                        case CONFIG_UPDATE_STREAM_ERROR:
-                          userInfoMap.putString("code", "config_update_stream_error");
-                          break;
-                        case CONFIG_UPDATE_MESSAGE_INVALID:
-                          userInfoMap.putString("code", "config_update_message_invalid");
-                          break;
-                        case CONFIG_UPDATE_NOT_FETCHED:
-                          userInfoMap.putString("code", "config_update_not_fetched");
-                          break;
-                        case CONFIG_UPDATE_UNAVAILABLE:
-                          userInfoMap.putString("code", "config_update_unavailable");
-                          break;
-                        case UNKNOWN:
-                          userInfoMap.putString("code", "unknown");
-                          break;
-                        default:
-                          userInfoMap.putString("code", "internal");
-                      }
-
-                      userInfoMap.putString("message", error.getMessage());
-                      userInfoMap.putString("nativeErrorMessage", error.getMessage());
-                      ReactNativeFirebaseEvent event =
-                          new ReactNativeFirebaseEvent("on_config_updated", userInfoMap, appName);
-                      emitter.sendEvent(event);
+    ConfigUpdateListenerRegistration registration =
+        FirebaseRemoteConfig.getInstance(FirebaseApp.getInstance(appName))
+            .addOnConfigUpdateListener(
+                new ConfigUpdateListener() {
+                  @Override
+                  public void onUpdate(@NotNull ConfigUpdate configUpdate) {
+                    ReactNativeFirebaseEventEmitter emitter =
+                        ReactNativeFirebaseEventEmitter.getSharedInstance();
+
+                    Set<String> updatedKeys = configUpdate.getUpdatedKeys();
+                    List<String> updatedKeysList = new ArrayList<>(updatedKeys);
+
+                    Map<String, Object> results = new HashMap<>();
+                    results.put("appName", appName);
+                    results.put("resultType", "success");
+                    results.put("updatedKeys", updatedKeysList);
+                    ReactNativeFirebaseEvent event =
+                        new ReactNativeFirebaseEvent(
+                            "on_config_updated", Arguments.makeNativeMap(results), appName);
+                    emitter.sendEvent(event);
+                  }
+
+                  @Override
+                  public void onError(@NotNull FirebaseRemoteConfigException error) {
+                    ReactNativeFirebaseEventEmitter emitter =
+                        ReactNativeFirebaseEventEmitter.getSharedInstance();
+
+                    WritableMap userInfoMap = Arguments.createMap();
+                    userInfoMap.putString("resultType", "error");
+                    userInfoMap.putString("appName", appName);
+
+                    FirebaseRemoteConfigException.Code code = error.getCode();
+                    switch (code) {
+                      case CONFIG_UPDATE_STREAM_ERROR:
+                        userInfoMap.putString("code", "config_update_stream_error");
+                        break;
+                      case CONFIG_UPDATE_MESSAGE_INVALID:
+                        userInfoMap.putString("code", "config_update_message_invalid");
+                        break;
+                      case CONFIG_UPDATE_NOT_FETCHED:
+                        userInfoMap.putString("code", "config_update_not_fetched");
+                        break;
+                      case CONFIG_UPDATE_UNAVAILABLE:
+                        userInfoMap.putString("code", "config_update_unavailable");
+                        break;
+                      case UNKNOWN:
+                        userInfoMap.putString("code", "unknown");
+                        break;
+                      default:
+                        userInfoMap.putString("code", "internal");
                     }
-                  });
 
-      mConfigUpdateRegistrations.put(appName, registration);
-    }
+                    userInfoMap.putString("message", error.getMessage());
+                    userInfoMap.putString("nativeErrorMessage", error.getMessage());
+                    ReactNativeFirebaseEvent event =
+                        new ReactNativeFirebaseEvent("on_config_updated", userInfoMap, appName);
+                    emitter.sendEvent(event);
+                  }
+                });
+
+    configUpdateListeners.putOrDiscard(appName, registration::remove);
   }
 
   @Override
   public void removeConfigUpdateRegistration(String appName) {
-    ConfigUpdateListenerRegistration mConfigRegistration = mConfigUpdateRegistrations.get(appName);
-
-    if (mConfigRegistration != null) {
-      mConfigRegistration.remove();
-      mConfigUpdateRegistrations.remove(appName);
-    }
+    configUpdateListeners.takeAndRemove(appName);
   }
 
   @Override

package/android/src/test/java/io/invertase/firebase/config/RNFBRemoteConfigListenerRegistryTest.java

@@ -0,0 +1,171 @@
+package io.invertase.firebase.config;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import io.invertase.firebase.common.RNFBHandleCollisionException;
+import org.junit.Test;
+
+/**
+ * JVM coverage for {@link RNFBRemoteConfigListenerRegistry}. Does not instantiate {@code
+ * NativeRNFBTurboConfig} (React Native / Firebase) — D12.
+ */
+public class RNFBRemoteConfigListenerRegistryTest {
+
+  private static final class FakeHandle implements ConfigUpdateListenerHandle {
+    int removeCount;
+
+    @Override
+    public void remove() {
+      removeCount++;
+    }
+  }
+
+  @Test
+  public void putGetTake_happyPath() throws Exception {
+    RNFBRemoteConfigListenerRegistry registry = new RNFBRemoteConfigListenerRegistry();
+    FakeHandle handle = new FakeHandle();
+    registry.put("app", handle);
+    assertSame(handle, registry.get("app"));
+    assertSame(handle, registry.take("app"));
+    assertNull(registry.get("app"));
+    assertEquals(0, handle.removeCount);
+  }
+
+  @Test
+  public void put_occupiedId_throwsCollision() throws Exception {
+    RNFBRemoteConfigListenerRegistry registry = new RNFBRemoteConfigListenerRegistry();
+    FakeHandle first = new FakeHandle();
+    registry.put("app", first);
+    try {
+      registry.put("app", new FakeHandle());
+      fail("expected RNFBHandleCollisionException");
+    } catch (RNFBHandleCollisionException e) {
+      assertTrue(e.getMessage().contains("app"));
+      assertSame(first, registry.get("app"));
+    }
+  }
+
+  @Test
+  public void get_whenFree_isNull() {
+    RNFBRemoteConfigListenerRegistry registry = new RNFBRemoteConfigListenerRegistry();
+    assertNull(registry.get("app"));
+  }
+
+  @Test
+  public void get_whenOccupied_returnsHandle() throws Exception {
+    RNFBRemoteConfigListenerRegistry registry = new RNFBRemoteConfigListenerRegistry();
+    FakeHandle first = new FakeHandle();
+    registry.put("app", first);
+    assertSame(first, registry.get("app"));
+  }
+
+  @Test
+  public void putOrDiscard_collision_removesIncoming() throws Exception {
+    RNFBRemoteConfigListenerRegistry registry = new RNFBRemoteConfigListenerRegistry();
+    FakeHandle first = new FakeHandle();
+    FakeHandle duplicate = new FakeHandle();
+    registry.put("app", first);
+    assertFalse(registry.putOrDiscard("app", duplicate));
+    assertEquals(1, duplicate.removeCount);
+    assertEquals(0, first.removeCount);
+    assertSame(first, registry.get("app"));
+  }
+
+  @Test
+  public void putOrDiscard_storesWhenFree() {
+    RNFBRemoteConfigListenerRegistry registry = new RNFBRemoteConfigListenerRegistry();
+    FakeHandle handle = new FakeHandle();
+    assertTrue(registry.putOrDiscard("app", handle));
+    assertSame(handle, registry.get("app"));
+    assertEquals(0, handle.removeCount);
+  }
+
+  @Test
+  public void putOrDiscard_collision_nullIncoming_isNoOp() throws Exception {
+    RNFBRemoteConfigListenerRegistry registry = new RNFBRemoteConfigListenerRegistry();
+    FakeHandle first = new FakeHandle();
+    registry.put("app", first);
+    assertFalse(registry.putOrDiscard("app", null));
+    assertSame(first, registry.get("app"));
+  }
+
+  @Test
+  public void takeAndRemove_removesAfterTake() throws Exception {
+    RNFBRemoteConfigListenerRegistry registry = new RNFBRemoteConfigListenerRegistry();
+    FakeHandle handle = new FakeHandle();
+    registry.put("app", handle);
+    registry.takeAndRemove("app");
+    assertEquals(1, handle.removeCount);
+    assertNull(registry.get("app"));
+  }
+
+  @Test
+  public void takeAndRemove_missingKey_isNoOp() {
+    RNFBRemoteConfigListenerRegistry registry = new RNFBRemoteConfigListenerRegistry();
+    registry.takeAndRemove("missing");
+    assertNull(registry.get("missing"));
+  }
+
+  @Test
+  public void takeAllAndRemove_removesSnapshotAndLeavesEmpty() throws Exception {
+    RNFBRemoteConfigListenerRegistry registry = new RNFBRemoteConfigListenerRegistry();
+    FakeHandle a = new FakeHandle();
+    FakeHandle b = new FakeHandle();
+    registry.put("a", a);
+    registry.put("b", b);
+    registry.takeAllAndRemove();
+    assertEquals(1, a.removeCount);
+    assertEquals(1, b.removeCount);
+    assertNull(registry.get("a"));
+    assertNull(registry.get("b"));
+  }
+
+  @Test
+  public void takeAllAndRemove_empty_isNoOp() {
+    RNFBRemoteConfigListenerRegistry registry = new RNFBRemoteConfigListenerRegistry();
+    registry.takeAllAndRemove();
+    assertNull(registry.get("app"));
+  }
+
+  @Test
+  public void takeAllAndRemove_nullHandle_isNoOp() throws Exception {
+    RNFBRemoteConfigListenerRegistry registry = new RNFBRemoteConfigListenerRegistry();
+    registry.put("app", null);
+    registry.takeAllAndRemove();
+    assertNull(registry.get("app"));
+  }
+
+  @Test
+  public void put_afterTake_allowsReuse() throws Exception {
+    RNFBRemoteConfigListenerRegistry registry = new RNFBRemoteConfigListenerRegistry();
+    FakeHandle first = new FakeHandle();
+    FakeHandle second = new FakeHandle();
+    registry.put("app", first);
+    assertSame(first, registry.take("app"));
+    registry.put("app", second);
+    assertSame(second, registry.get("app"));
+    assertEquals(0, first.removeCount);
+  }
+}

package/dist/module/version.js

@@ -1,5 +1,5 @@
 "use strict";
 
 // Generated by genversion.
-export const version = '26.3.3';
+export const version = '26.4.0';
 //# sourceMappingURL=version.js.map

package/dist/typescript/lib/index.d.ts

@@ -3,7 +3,7 @@ import { LastFetchStatus, ValueSource } from './statics';
 import type { ConfigUpdateObserver, CustomSignals, LogLevel, RemoteConfig, RemoteConfigOptions, Unsubscribe, Value } from './types/remote-config';
 import './types/internal';
 export { LastFetchStatus, ValueSource };
-export declare const SDK_VERSION = "26.3.3";
+export declare const SDK_VERSION = "26.4.0";
 /**
  * Returns a RemoteConfig instance for the given app.
  * @param app - FirebaseApp. Optional.

package/dist/typescript/lib/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "26.3.3";
+export declare const version = "26.4.0";
 //# sourceMappingURL=version.d.ts.map

package/ios/RNFBConfig/RNFBConfigHelper.m

@@ -26,10 +26,11 @@
 #import "RNFBApp/RCTConvert+FIRApp.h"
 #import "RNFBApp/RNFBSharedUtils.h"
 #import "RNFBConfigHelper.h"
+#import "RNFBRemoteConfigListenerRegistry.h"
 
 static NSString *const ON_CONFIG_UPDATED_EVENT = @"on_config_updated";
 
-static __strong NSMutableDictionary *configUpdateHandlers;
+static __strong RNFBRemoteConfigListenerRegistry *configUpdateHandlers;
 
 static NSString *convertFIRRemoteConfigFetchStatusToNSString(FIRRemoteConfigFetchStatus value) {
   switch (value) {
@@ -98,6 +99,13 @@ static FIRApp *firebaseAppForName(NSString *appName) {
 
 @implementation RNFBConfigHelper
 
++ (void)initializeConfigUpdateHandlersOnce {
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    configUpdateHandlers = [[RNFBRemoteConfigListenerRegistry alloc] init];
+  });
+}
+
 + (NSDictionary *)getConstantsForAppName:(NSString *)appName {
   FIRApp *firebaseApp = firebaseAppForName(appName);
   return [self getConstantsForApp:firebaseApp];
@@ -311,61 +319,54 @@ static FIRApp *firebaseAppForName(NSString *appName) {
 }
 
 + (void)onConfigUpdated:(NSString *)appName {
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    configUpdateHandlers = [[NSMutableDictionary alloc] init];
-  });
+  [self initializeConfigUpdateHandlersOnce];
 
   FIRApp *firebaseApp = firebaseAppForName(appName);
-  if (![configUpdateHandlers valueForKey:firebaseApp.name]) {
-    FIRConfigUpdateListenerRegistration *newRegistration =
-        [[FIRRemoteConfig remoteConfigWithApp:firebaseApp]
-            addOnConfigUpdateListener:^(FIRRemoteConfigUpdate *_Nonnull configUpdate,
-                                        NSError *_Nullable error) {
-              if (error != nil) {
-                NSMutableDictionary *userInfo = [NSMutableDictionary dictionary];
-
-                [userInfo setValue:@"error" forKey:@"resultType"];
-                [userInfo setValue:convertFIRRemoteConfigUpdateErrorToNSString(
-                                       (FIRRemoteConfigUpdateError)error.code)
-                            forKey:@"code"];
-                [userInfo setValue:error.localizedDescription forKey:@"message"];
-                [userInfo setValue:error.localizedDescription forKey:@"nativeErrorMessage"];
-                [RNFBSharedUtils sendJSEventForApp:firebaseApp
-                                              name:ON_CONFIG_UPDATED_EVENT
-                                              body:userInfo];
-                return;
-              }
-
-              NSMutableDictionary *results = [NSMutableDictionary dictionary];
-
-              [results setValue:@"success" forKey:@"resultType"];
-              [results setValue:[configUpdate.updatedKeys allObjects] forKey:@"updatedKeys"];
+  if ([configUpdateHandlers get:firebaseApp.name] != nil) {
+    return;
+  }
 
+  FIRConfigUpdateListenerRegistration *newRegistration =
+      [[FIRRemoteConfig remoteConfigWithApp:firebaseApp]
+          addOnConfigUpdateListener:^(FIRRemoteConfigUpdate *_Nonnull configUpdate,
+                                      NSError *_Nullable error) {
+            if (error != nil) {
+              NSMutableDictionary *userInfo = [NSMutableDictionary dictionary];
+
+              [userInfo setValue:@"error" forKey:@"resultType"];
+              [userInfo setValue:convertFIRRemoteConfigUpdateErrorToNSString(
+                                     (FIRRemoteConfigUpdateError)error.code)
+                          forKey:@"code"];
+              [userInfo setValue:error.localizedDescription forKey:@"message"];
+              [userInfo setValue:error.localizedDescription forKey:@"nativeErrorMessage"];
               [RNFBSharedUtils sendJSEventForApp:firebaseApp
                                             name:ON_CONFIG_UPDATED_EVENT
-                                            body:results];
-            }];
+                                            body:userInfo];
+              return;
+            }
 
-    configUpdateHandlers[firebaseApp.name] = newRegistration;
-  }
+            NSMutableDictionary *results = [NSMutableDictionary dictionary];
+
+            [results setValue:@"success" forKey:@"resultType"];
+            [results setValue:[configUpdate.updatedKeys allObjects] forKey:@"updatedKeys"];
+
+            [RNFBSharedUtils sendJSEventForApp:firebaseApp
+                                          name:ON_CONFIG_UPDATED_EVENT
+                                          body:results];
+          }];
+
+  [configUpdateHandlers putOrDiscard:firebaseApp.name value:newRegistration];
 }
 
 + (void)removeConfigUpdateRegistration:(NSString *)appName {
+  [self initializeConfigUpdateHandlersOnce];
   FIRApp *firebaseApp = firebaseAppForName(appName);
-  if ([configUpdateHandlers valueForKey:firebaseApp.name]) {
-    [[configUpdateHandlers objectForKey:firebaseApp.name] remove];
-    [configUpdateHandlers removeObjectForKey:firebaseApp.name];
-  }
+  [configUpdateHandlers takeAndRemove:firebaseApp.name];
 }
 
 + (void)removeAllConfigUpdateRegistrations {
-  for (NSString *key in [configUpdateHandlers allKeys]) {
-    FIRConfigUpdateListenerRegistration *registration = [configUpdateHandlers objectForKey:key];
-    [registration remove];
-  }
-
-  [configUpdateHandlers removeAllObjects];
+  [self initializeConfigUpdateHandlersOnce];
+  [configUpdateHandlers removeAll];
 }
 
 + (void)setCustomSignals:(NSString *)appName

package/ios/RNFBConfig/RNFBRemoteConfigListenerRegistry.h

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Remote Config update-listener map. Unique `put` / `putOrDiscard`; callers `take` or `removeAll`
+ * then `remove` outside the HandleMap lock. Skip-if-registered is `get != nil`. Stored values are
+ * expected to respond to `remove`.
+ */
+@interface RNFBRemoteConfigListenerRegistry : NSObject
+
+- (BOOL)put:(id)key value:(id)value error:(NSError *_Nullable *_Nullable)error;
+/// Unique put. On collision, `remove`s the incoming value and leaves the existing mapping.
+- (BOOL)putOrDiscard:(id)key value:(id)value;
+- (nullable id)get:(id)key;
+- (nullable id)take:(id)key;
+- (void)takeAndRemove:(id)key;
+- (void)removeAll;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNFBConfig/RNFBRemoteConfigListenerRegistry.m

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import "RNFBRemoteConfigListenerRegistry.h"
+
+#if __has_include("RNFBHandleMap.h")
+#import "RNFBHandleMap.h"
+#else
+#import "RNFBApp/RNFBHandleMap.h"
+#endif
+
+@protocol RNFBRemoteConfigRemovable <NSObject>
+- (void)remove;
+@end
+
+@interface RNFBRemoteConfigListenerRegistry ()
+@property(nonatomic, strong) RNFBHandleMap *map;
+@end
+
+@implementation RNFBRemoteConfigListenerRegistry
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _map = [[RNFBHandleMap alloc] init];
+  }
+  return self;
+}
+
+- (void)rnfb_removeHandle:(id)handle {
+  if (handle && [handle respondsToSelector:@selector(remove)]) {
+    [(id<RNFBRemoteConfigRemovable>)handle remove];
+  }
+}
+
+- (BOOL)put:(id)key value:(id)value error:(NSError **)error {
+  return [self.map put:key value:value error:error];
+}
+
+- (BOOL)putOrDiscard:(id)key value:(id)value {
+  NSError *error = nil;
+  if ([self.map put:key value:value error:&error]) {
+    return YES;
+  }
+  [self rnfb_removeHandle:value];
+  return NO;
+}
+
+- (id)get:(id)key {
+  return [self.map get:key];
+}
+
+- (id)take:(id)key {
+  return [self.map take:key];
+}
+
+- (void)takeAndRemove:(id)key {
+  id handle = [self.map take:key];
+  [self rnfb_removeHandle:handle];
+}
+
+- (void)removeAll {
+  NSArray *handlers = [self.map takeAll];
+  for (id handler in handlers) {
+    [self rnfb_removeHandle:handler];
+  }
+}
+
+@end

package/ios/RNFBRemoteConfigUnitTests/RNFBRemoteConfigListenerRegistryTests.m

@@ -0,0 +1,154 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import <XCTest/XCTest.h>
+
+#import "RNFBHandleMap.h"
+#import "RNFBRemoteConfigListenerRegistry.h"
+
+@interface FakeRemoteConfigListenerHandle : NSObject
+@property(nonatomic, assign) NSInteger removeCount;
+- (void)remove;
+@end
+
+@implementation FakeRemoteConfigListenerHandle
+- (void)remove {
+  self.removeCount += 1;
+}
+@end
+
+@interface RNFBRemoteConfigListenerRegistryTests : XCTestCase
+@property(nonatomic, strong) RNFBRemoteConfigListenerRegistry *registry;
+@end
+
+@implementation RNFBRemoteConfigListenerRegistryTests
+
+- (void)setUp {
+  [super setUp];
+  self.registry = [[RNFBRemoteConfigListenerRegistry alloc] init];
+}
+
+- (void)testPutGetTake_happyPath {
+  FakeRemoteConfigListenerHandle *handle = [[FakeRemoteConfigListenerHandle alloc] init];
+  NSError *error = nil;
+  XCTAssertTrue([self.registry put:@"app" value:handle error:&error]);
+  XCTAssertNil(error);
+  XCTAssertEqual(handle, [self.registry get:@"app"]);
+  XCTAssertEqual(handle, [self.registry take:@"app"]);
+  XCTAssertNil([self.registry get:@"app"]);
+  XCTAssertEqual(handle.removeCount, 0);
+}
+
+- (void)testPut_occupiedId_returnsCollision {
+  FakeRemoteConfigListenerHandle *first = [[FakeRemoteConfigListenerHandle alloc] init];
+  XCTAssertTrue([self.registry put:@"app" value:first error:nil]);
+
+  NSError *error = nil;
+  XCTAssertFalse([self.registry put:@"app"
+                              value:[[FakeRemoteConfigListenerHandle alloc] init]
+                              error:&error]);
+  XCTAssertNotNil(error);
+  XCTAssertEqualObjects(error.domain, RNFBHandleMapErrorDomain);
+  XCTAssertEqual(error.code, RNFBHandleMapErrorCollision);
+  XCTAssertEqual(first, [self.registry get:@"app"]);
+}
+
+- (void)testPut_occupiedId_nilErrorOut_returnsNo {
+  FakeRemoteConfigListenerHandle *first = [[FakeRemoteConfigListenerHandle alloc] init];
+  XCTAssertTrue([self.registry put:@"app" value:first error:nil]);
+  XCTAssertFalse([self.registry put:@"app"
+                              value:[[FakeRemoteConfigListenerHandle alloc] init]
+                              error:nil]);
+  XCTAssertEqual(first, [self.registry get:@"app"]);
+}
+
+- (void)testGet_whenFree_isNil {
+  XCTAssertNil([self.registry get:@"app"]);
+}
+
+- (void)testGet_whenOccupied_returnsHandle {
+  FakeRemoteConfigListenerHandle *first = [[FakeRemoteConfigListenerHandle alloc] init];
+  XCTAssertTrue([self.registry put:@"app" value:first error:nil]);
+  XCTAssertEqual(first, [self.registry get:@"app"]);
+}
+
+- (void)testPutOrDiscard_collision_removesIncoming {
+  FakeRemoteConfigListenerHandle *first = [[FakeRemoteConfigListenerHandle alloc] init];
+  FakeRemoteConfigListenerHandle *duplicate = [[FakeRemoteConfigListenerHandle alloc] init];
+  XCTAssertTrue([self.registry put:@"app" value:first error:nil]);
+  XCTAssertFalse([self.registry putOrDiscard:@"app" value:duplicate]);
+  XCTAssertEqual(duplicate.removeCount, 1);
+  XCTAssertEqual(first.removeCount, 0);
+  XCTAssertEqual(first, [self.registry get:@"app"]);
+}
+
+- (void)testPutOrDiscard_storesWhenFree {
+  FakeRemoteConfigListenerHandle *handle = [[FakeRemoteConfigListenerHandle alloc] init];
+  XCTAssertTrue([self.registry putOrDiscard:@"app" value:handle]);
+  XCTAssertEqual(handle, [self.registry get:@"app"]);
+  XCTAssertEqual(handle.removeCount, 0);
+}
+
+- (void)testTakeAndRemove_removesAfterTake {
+  FakeRemoteConfigListenerHandle *handle = [[FakeRemoteConfigListenerHandle alloc] init];
+  XCTAssertTrue([self.registry put:@"app" value:handle error:nil]);
+  [self.registry takeAndRemove:@"app"];
+  XCTAssertEqual(handle.removeCount, 1);
+  XCTAssertNil([self.registry get:@"app"]);
+}
+
+- (void)testTakeAndRemove_missingKey_isNoOp {
+  [self.registry takeAndRemove:@"missing"];
+}
+
+- (void)testRemoveAll_removesSnapshotAndLeavesEmpty {
+  FakeRemoteConfigListenerHandle *a = [[FakeRemoteConfigListenerHandle alloc] init];
+  FakeRemoteConfigListenerHandle *b = [[FakeRemoteConfigListenerHandle alloc] init];
+  XCTAssertTrue([self.registry put:@"a" value:a error:nil]);
+  XCTAssertTrue([self.registry put:@"b" value:b error:nil]);
+  [self.registry removeAll];
+  XCTAssertEqual(a.removeCount, 1);
+  XCTAssertEqual(b.removeCount, 1);
+  XCTAssertNil([self.registry get:@"a"]);
+  XCTAssertNil([self.registry get:@"b"]);
+}
+
+- (void)testPut_afterTake_allowsReuse {
+  FakeRemoteConfigListenerHandle *first = [[FakeRemoteConfigListenerHandle alloc] init];
+  FakeRemoteConfigListenerHandle *second = [[FakeRemoteConfigListenerHandle alloc] init];
+  XCTAssertTrue([self.registry put:@"app" value:first error:nil]);
+  XCTAssertEqual(first, [self.registry take:@"app"]);
+  XCTAssertTrue([self.registry put:@"app" value:second error:nil]);
+  XCTAssertEqual(second, [self.registry get:@"app"]);
+  XCTAssertEqual(first.removeCount, 0);
+}
+
+- (void)testRemoveAll_objectWithoutRemove_doesNotCrash {
+  NSObject *plain = [[NSObject alloc] init];
+  XCTAssertTrue([self.registry put:@"plain" value:plain error:nil]);
+  [self.registry removeAll];
+  XCTAssertNil([self.registry get:@"plain"]);
+}
+
+- (void)testTakeAndRemove_objectWithoutRemove_doesNotCrash {
+  NSObject *plain = [[NSObject alloc] init];
+  XCTAssertTrue([self.registry put:@"plain" value:plain error:nil]);
+  [self.registry takeAndRemove:@"plain"];
+  XCTAssertNil([self.registry get:@"plain"]);
+}
+
+@end

package/ios/RNFBRemoteConfigUnitTests/RNFBRemoteConfigUnitTests.xcodeproj/project.pbxproj

@@ -0,0 +1,251 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 56;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		A9000000000000000000000A /* RNFBHandleMap.m in Sources */ = {isa = PBXBuildFile; fileRef = A90000000000000000000008 /* RNFBHandleMap.m */; };
+		A9000000000000000000000B /* RNFBRemoteConfigListenerRegistry.m in Sources */ = {isa = PBXBuildFile; fileRef = A90000000000000000000018 /* RNFBRemoteConfigListenerRegistry.m */; };
+		A9000000000000000000000C /* RNFBRemoteConfigListenerRegistryTests.m in Sources */ = {isa = PBXBuildFile; fileRef = A90000000000000000000009 /* RNFBRemoteConfigListenerRegistryTests.m */; };
+		A90000000000000000000015 /* XCTest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A90000000000000000000014 /* XCTest.framework */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		A90000000000000000000003 /* RNFBRemoteConfigUnitTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RNFBRemoteConfigUnitTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+		A90000000000000000000007 /* RNFBHandleMap.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RNFBHandleMap.h; path = ../../../app/ios/RNFBApp/RNFBHandleMap.h; sourceTree = SOURCE_ROOT; };
+		A90000000000000000000008 /* RNFBHandleMap.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = RNFBHandleMap.m; path = ../../../app/ios/RNFBApp/RNFBHandleMap.m; sourceTree = SOURCE_ROOT; };
+		A90000000000000000000009 /* RNFBRemoteConfigListenerRegistryTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNFBRemoteConfigListenerRegistryTests.m; sourceTree = "<group>"; };
+		A90000000000000000000016 /* RNFBRemoteConfigListenerRegistry.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RNFBRemoteConfigListenerRegistry.h; path = ../RNFBConfig/RNFBRemoteConfigListenerRegistry.h; sourceTree = SOURCE_ROOT; };
+		A90000000000000000000018 /* RNFBRemoteConfigListenerRegistry.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = RNFBRemoteConfigListenerRegistry.m; path = ../RNFBConfig/RNFBRemoteConfigListenerRegistry.m; sourceTree = SOURCE_ROOT; };
+		A90000000000000000000014 /* XCTest.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = XCTest.framework; path = Platforms/MacOSX.platform/Developer/Library/Frameworks/XCTest.framework; sourceTree = DEVELOPER_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		A9000000000000000000000D /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				A90000000000000000000015 /* XCTest.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		A90000000000000000000004 = {
+			isa = PBXGroup;
+			children = (
+				A90000000000000000000006 /* Sources */,
+				A90000000000000000000005 /* Products */,
+			);
+			sourceTree = "<group>";
+		};
+		A90000000000000000000005 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				A90000000000000000000003 /* RNFBRemoteConfigUnitTests.xctest */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		A90000000000000000000006 /* Sources */ = {
+			isa = PBXGroup;
+			children = (
+				A90000000000000000000007 /* RNFBHandleMap.h */,
+				A90000000000000000000008 /* RNFBHandleMap.m */,
+				A90000000000000000000016 /* RNFBRemoteConfigListenerRegistry.h */,
+				A90000000000000000000018 /* RNFBRemoteConfigListenerRegistry.m */,
+				A90000000000000000000009 /* RNFBRemoteConfigListenerRegistryTests.m */,
+			);
+			name = Sources;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		A90000000000000000000002 /* RNFBRemoteConfigUnitTests */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = A90000000000000000000013 /* Build configuration list for PBXNativeTarget "RNFBRemoteConfigUnitTests" */;
+			buildPhases = (
+				A9000000000000000000000E /* Sources */,
+				A9000000000000000000000D /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = RNFBRemoteConfigUnitTests;
+			productName = RNFBRemoteConfigUnitTests;
+			productReference = A90000000000000000000003 /* RNFBRemoteConfigUnitTests.xctest */;
+			productType = "com.apple.product-type.bundle.unit-test";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		A90000000000000000000001 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				BuildIndependentTargetsInParallel = 1;
+				LastUpgradeCheck = 2600;
+				ORGANIZATIONNAME = Invertase;
+				TargetAttributes = {
+					A90000000000000000000002 = {
+						CreatedOnToolsVersion = 26.0;
+					};
+				};
+			};
+			buildConfigurationList = A90000000000000000000012 /* Build configuration list for PBXProject "RNFBRemoteConfigUnitTests" */;
+			compatibilityVersion = "Xcode 14.0";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = A90000000000000000000004;
+			productRefGroup = A90000000000000000000005 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				A90000000000000000000002 /* RNFBRemoteConfigUnitTests */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		A9000000000000000000000E /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				A9000000000000000000000A /* RNFBHandleMap.m in Sources */,
+				A9000000000000000000000B /* RNFBRemoteConfigListenerRegistry.m in Sources */,
+				A9000000000000000000000C /* RNFBRemoteConfigListenerRegistryTests.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		A9000000000000000000001A /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu17;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				MACOSX_DEPLOYMENT_TARGET = 14.0;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = macosx;
+				SUPPORTED_PLATFORMS = macosx;
+			};
+			name = Debug;
+		};
+		A9000000000000000000001B /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				COPY_PHASE_STRIP = YES;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				GCC_C_LANGUAGE_STANDARD = gnu17;
+				MACOSX_DEPLOYMENT_TARGET = 14.0;
+				SDKROOT = macosx;
+				SUPPORTED_PLATFORMS = macosx;
+			};
+			name = Release;
+		};
+		A90000000000000000000010 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_ENABLE_CODE_COVERAGE = YES;
+				CODE_SIGNING_ALLOWED = NO;
+				CODE_SIGNING_REQUIRED = NO;
+				CODE_SIGN_IDENTITY = "-";
+				COMBINE_HIDPI_IMAGES = YES;
+				GENERATE_INFOPLIST_FILE = YES;
+				HEADER_SEARCH_PATHS = (
+					"$(SRCROOT)/../../../app/ios",
+					"$(SRCROOT)/../../../app/ios/RNFBApp",
+					"$(SRCROOT)/../RNFBConfig",
+				);
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/../Frameworks",
+					"@loader_path/../Frameworks",
+				);
+				MACOSX_DEPLOYMENT_TARGET = 14.0;
+				OTHER_CFLAGS = (
+					"-fprofile-instr-generate",
+					"-fcoverage-mapping",
+				);
+				OTHER_LDFLAGS = (
+					"-fprofile-instr-generate",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = io.invertase.firebase.RNFBRemoteConfigUnitTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = macosx;
+				SUPPORTED_PLATFORMS = macosx;
+			};
+			name = Debug;
+		};
+		A90000000000000000000011 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_ENABLE_CODE_COVERAGE = YES;
+				CODE_SIGNING_ALLOWED = NO;
+				CODE_SIGNING_REQUIRED = NO;
+				CODE_SIGN_IDENTITY = "-";
+				COMBINE_HIDPI_IMAGES = YES;
+				GENERATE_INFOPLIST_FILE = YES;
+				HEADER_SEARCH_PATHS = (
+					"$(SRCROOT)/../../../app/ios",
+					"$(SRCROOT)/../../../app/ios/RNFBApp",
+					"$(SRCROOT)/../RNFBConfig",
+				);
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/../Frameworks",
+					"@loader_path/../Frameworks",
+				);
+				MACOSX_DEPLOYMENT_TARGET = 14.0;
+				PRODUCT_BUNDLE_IDENTIFIER = io.invertase.firebase.RNFBRemoteConfigUnitTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = macosx;
+				SUPPORTED_PLATFORMS = macosx;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		A90000000000000000000012 /* Build configuration list for PBXProject "RNFBRemoteConfigUnitTests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				A9000000000000000000001A /* Debug */,
+				A9000000000000000000001B /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+		A90000000000000000000013 /* Build configuration list for PBXNativeTarget "RNFBRemoteConfigUnitTests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				A90000000000000000000010 /* Debug */,
+				A90000000000000000000011 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = A90000000000000000000001 /* Project object */;
+}

package/ios/RNFBRemoteConfigUnitTests/RNFBRemoteConfigUnitTests.xcodeproj/xcshareddata/xcschemes/RNFBRemoteConfigUnitTests.xcscheme

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "2600"
+   version = "1.7">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "NO"
+            buildForArchiving = "NO"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "A90000000000000000000002"
+               BuildableName = "RNFBRemoteConfigUnitTests.xctest"
+               BlueprintName = "RNFBRemoteConfigUnitTests"
+               ReferencedContainer = "container:RNFBRemoteConfigUnitTests.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      codeCoverageEnabled = "YES">
+      <Testables>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "A90000000000000000000002"
+               BuildableName = "RNFBRemoteConfigUnitTests.xctest"
+               BlueprintName = "RNFBRemoteConfigUnitTests"
+               ReferencedContainer = "container:RNFBRemoteConfigUnitTests.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

package/lib/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '26.3.3';
+export const version = '26.4.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-firebase/remote-config",
-  "version": "26.3.3",
+  "version": "26.4.0",
   "author": "Invertase <oss@invertase.io> (http://invertase.io)",
   "description": "React Native Firebase - React Native Firebase provides native integration with Remote Config, allowing you to change the appearance and/or functionality of your app without requiring an app update.",
   "main": "./dist/module/index.js",
@@ -28,6 +28,7 @@
     "android:codegen": "node ../../scripts/codegen-package.mjs remote-config android",
     "ios:codegen": "node ../../scripts/codegen-package.mjs remote-config ios"
   },
+  "homepage": "https://rnfirebase.io",
   "repository": {
     "type": "git",
     "url": "https://github.com/invertase/react-native-firebase",
@@ -43,8 +44,8 @@
     "remote-config"
   ],
   "peerDependencies": {
-    "@react-native-firebase/analytics": "26.3.3",
-    "@react-native-firebase/app": "26.3.3"
+    "@react-native-firebase/analytics": "26.4.0",
+    "@react-native-firebase/app": "26.4.0"
   },
   "publishConfig": {
     "access": "public",
@@ -56,7 +57,7 @@
     "web-streams-polyfill": "^4.2.0"
   },
   "devDependencies": {
-    "@react-native-firebase/app": "26.3.3",
+    "@react-native-firebase/app": "26.4.0",
     "@types/text-encoding": "^0.0.40",
     "react-native-builder-bob": "^0.41.0",
     "typescript": "^6.0.3"
@@ -91,5 +92,5 @@
     "node_modules/",
     "dist/"
   ],
-  "gitHead": "04b90008385bf69be74f3a333d0dfea43ba32e64"
+  "gitHead": "06701af5fdc19bae9f379567eadb29dfe81953c0"
 }