@react-native-firebase/perf 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
+
+- **perf, android:** use RNFBHandleMap for traces and http metrics ([60b6e7d](https://github.com/invertase/react-native-firebase/commit/60b6e7daa005d137228763291be0db75997b9162))
+
 ## [26.3.3](https://github.com/invertase/react-native-firebase/compare/v26.3.2...v26.3.3) (2026-09-01)
 
 ### Bug Fixes

package/RNFBPerf.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,swift}'
   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

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

package/android/src/main/java/io/invertase/firebase/perf/RNFBPerfHandleRegistry.java

@@ -0,0 +1,72 @@
+package io.invertase.firebase.perf;
+
+/*
+ * 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;
+import java.util.function.Predicate;
+
+/**
+ * Perf id → metric handle map (traces, screen traces, HTTP metrics). Module start paths use {@link
+ * #putReplacing} (last wins, stop displaced outside lock). Unique {@link #put} / {@link
+ * #putOrDiscard} remain for tests. Callers {@link #get} then {@link #take} then stop outside the
+ * HandleMap lock. Tear-down discards via {@link #takeAll} without stopping (matches prior
+ * SparseArray clear).
+ */
+final class RNFBPerfHandleRegistry<V> {
+  private final RNFBHandleMap<Integer, V> map = new RNFBHandleMap<>();
+
+  void put(int id, V handle) throws RNFBHandleCollisionException {
+    map.put(id, handle);
+  }
+
+  /**
+   * Unique put. On collision, drop the incoming handle without stopping and leave the existing
+   * mapping.
+   *
+   * @return true if stored
+   */
+  boolean putOrDiscard(int id, V handle) {
+    return map.putIfAbsent(id, handle);
+  }
+
+  /**
+   * Atomically replaces the mapping for {@code id} (last wins). Returns the displaced handle, or
+   * {@code null} if the id was free. Stop the displaced handle after this method returns.
+   */
+  V putReplacing(int id, V handle) {
+    return map.putReplacing(id, handle);
+  }
+
+  V get(int id) {
+    return map.get(id);
+  }
+
+  V take(int id) {
+    return map.take(id);
+  }
+
+  V takeIf(int id, Predicate<V> shouldTake) {
+    return map.takeIf(id, shouldTake);
+  }
+
+  List<V> takeAll() {
+    return map.takeAll();
+  }
+}

package/android/src/main/java/io/invertase/firebase/perf/UniversalFirebasePerfModule.java

@@ -20,7 +20,6 @@ package io.invertase.firebase.perf;
 import android.app.Activity;
 import android.content.Context;
 import android.os.Bundle;
-import android.util.SparseArray;
 import com.google.android.gms.tasks.Task;
 import com.google.android.gms.tasks.Tasks;
 import com.google.firebase.perf.FirebasePerformance;
@@ -33,9 +32,11 @@ import java.util.Objects;
 import java.util.Set;
 
 public class UniversalFirebasePerfModule extends UniversalFirebaseModule {
-  private static SparseArray<Trace> traces = new SparseArray<>();
-  private static SparseArray<ScreenTrace> screenTraces = new SparseArray<>();
-  private static SparseArray<HttpMetric> httpMetrics = new SparseArray<>();
+  private static final RNFBPerfHandleRegistry<Trace> traces = new RNFBPerfHandleRegistry<>();
+  private static final RNFBPerfHandleRegistry<ScreenTrace> screenTraces =
+      new RNFBPerfHandleRegistry<>();
+  private static final RNFBPerfHandleRegistry<HttpMetric> httpMetrics =
+      new RNFBPerfHandleRegistry<>();
 
   UniversalFirebasePerfModule(Context context, String serviceName) {
     super(context, serviceName);
@@ -44,9 +45,10 @@ public class UniversalFirebasePerfModule extends UniversalFirebaseModule {
   @Override
   public void onTearDown() {
     super.onTearDown();
-    traces.clear();
-    httpMetrics.clear();
-    screenTraces.clear();
+    // Drop mappings only — matches prior SparseArray.clear() (no stop/cancel).
+    traces.takeAll();
+    httpMetrics.takeAll();
+    screenTraces.takeAll();
   }
 
   @Override
@@ -72,9 +74,7 @@ public class UniversalFirebasePerfModule extends UniversalFirebaseModule {
         () -> {
           Trace trace = FirebasePerformance.getInstance().newTrace(identifier);
           trace.start();
-
-          traces.put(id, trace);
-
+          registerStartedTrace(id, trace);
           return null;
         });
   }
@@ -101,8 +101,10 @@ public class UniversalFirebasePerfModule extends UniversalFirebaseModule {
                 attributeKey, (String) Objects.requireNonNull(attributes.get(attributeKey)));
           }
 
-          trace.stop();
-          traces.remove(id);
+          Trace taken = traces.takeIf(id, t -> t == trace);
+          if (taken != null) {
+            taken.stop();
+          }
 
           return null;
         });
@@ -113,8 +115,7 @@ public class UniversalFirebasePerfModule extends UniversalFirebaseModule {
         () -> {
           ScreenTrace screenTrace = new ScreenTrace(activity, identifier);
           screenTrace.recordScreenTrace();
-          screenTraces.put(id, screenTrace);
-
+          registerRecordedScreenTrace(id, screenTrace);
           return null;
         });
   }
@@ -127,8 +128,11 @@ public class UniversalFirebasePerfModule extends UniversalFirebaseModule {
           if (trace == null) {
             return null;
           }
-          trace.sendScreenTrace();
-          screenTraces.remove(id);
+
+          ScreenTrace taken = screenTraces.takeIf(id, t -> t == trace);
+          if (taken != null) {
+            taken.sendScreenTrace();
+          }
 
           return null;
         });
@@ -139,7 +143,7 @@ public class UniversalFirebasePerfModule extends UniversalFirebaseModule {
         () -> {
           HttpMetric httpMetric = FirebasePerformance.getInstance().newHttpMetric(url, httpMethod);
           httpMetric.start();
-          httpMetrics.put(id, httpMetric);
+          registerStartedHttpMetric(id, httpMetric);
           return null;
         });
   }
@@ -178,8 +182,10 @@ public class UniversalFirebasePerfModule extends UniversalFirebaseModule {
                 attributeKey, Objects.requireNonNull(attributes.getString(attributeKey)));
           }
 
-          httpMetric.stop();
-          httpMetrics.remove(id);
+          HttpMetric taken = httpMetrics.takeIf(id, m -> m == httpMetric);
+          if (taken != null) {
+            taken.stop();
+          }
 
           return null;
         });
@@ -190,7 +196,7 @@ public class UniversalFirebasePerfModule extends UniversalFirebaseModule {
   void startTraceSync(int id, String identifier) {
     Trace trace = FirebasePerformance.getInstance().newTrace(identifier);
     trace.start();
-    traces.put(id, trace);
+    registerStartedTrace(id, trace);
   }
 
   void stopTraceSync(int id, Bundle metrics, Bundle attributes) {
@@ -213,14 +219,16 @@ public class UniversalFirebasePerfModule extends UniversalFirebaseModule {
           attributeKey, (String) Objects.requireNonNull(attributes.get(attributeKey)));
     }
 
-    trace.stop();
-    traces.remove(id);
+    Trace taken = traces.takeIf(id, t -> t == trace);
+    if (taken != null) {
+      taken.stop();
+    }
   }
 
   void startScreenTraceSync(Activity activity, int id, String identifier) {
     ScreenTrace screenTrace = new ScreenTrace(activity, identifier);
     screenTrace.recordScreenTrace();
-    screenTraces.put(id, screenTrace);
+    registerRecordedScreenTrace(id, screenTrace);
   }
 
   void stopScreenTraceSync(int id) {
@@ -229,14 +237,17 @@ public class UniversalFirebasePerfModule extends UniversalFirebaseModule {
     if (trace == null) {
       return;
     }
-    trace.sendScreenTrace();
-    screenTraces.remove(id);
+
+    ScreenTrace taken = screenTraces.takeIf(id, t -> t == trace);
+    if (taken != null) {
+      taken.sendScreenTrace();
+    }
   }
 
   void startHttpMetricSync(int id, String url, String httpMethod) {
     HttpMetric httpMetric = FirebasePerformance.getInstance().newHttpMetric(url, httpMethod);
     httpMetric.start();
-    httpMetrics.put(id, httpMetric);
+    registerStartedHttpMetric(id, httpMetric);
   }
 
   void stopHttpMetricSync(int id, Bundle httpMetricConfig, Bundle attributes) {
@@ -269,7 +280,33 @@ public class UniversalFirebasePerfModule extends UniversalFirebaseModule {
           attributeKey, Objects.requireNonNull(attributes.getString(attributeKey)));
     }
 
-    httpMetric.stop();
-    httpMetrics.remove(id);
+    HttpMetric taken = httpMetrics.takeIf(id, m -> m == httpMetric);
+    if (taken != null) {
+      taken.stop();
+    }
+  }
+
+  /** Last-wins registration: stop any displaced trace outside the HandleMap lock. */
+  private static void registerStartedTrace(int id, Trace trace) {
+    Trace displaced = traces.putReplacing(id, trace);
+    if (displaced != null) {
+      displaced.stop();
+    }
+  }
+
+  /** Last-wins registration: stop any displaced HTTP metric outside the HandleMap lock. */
+  private static void registerStartedHttpMetric(int id, HttpMetric httpMetric) {
+    HttpMetric displaced = httpMetrics.putReplacing(id, httpMetric);
+    if (displaced != null) {
+      displaced.stop();
+    }
+  }
+
+  /** Last-wins registration: finalize any displaced screen trace outside the HandleMap lock. */
+  private static void registerRecordedScreenTrace(int id, ScreenTrace screenTrace) {
+    ScreenTrace displaced = screenTraces.putReplacing(id, screenTrace);
+    if (displaced != null) {
+      displaced.sendScreenTrace();
+    }
   }
 }

package/android/src/test/java/io/invertase/firebase/perf/RNFBPerfHandleRegistryTest.java

@@ -0,0 +1,175 @@
+package io.invertase.firebase.perf;
+
+/*
+ * 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 java.util.List;
+import org.junit.Test;
+
+/**
+ * JVM coverage for {@link RNFBPerfHandleRegistry}. Does not instantiate {@code
+ * UniversalFirebasePerfModule} / Firebase Perf types — D12.
+ */
+public class RNFBPerfHandleRegistryTest {
+
+  @Test
+  public void putTake_happyPath() throws Exception {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    registry.put(1, "trace");
+    assertSame("trace", registry.take(1));
+    assertNull(registry.take(1));
+  }
+
+  @Test
+  public void put_occupiedId_throwsCollision() throws Exception {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    registry.put(1, "first");
+    try {
+      registry.put(1, "second");
+      fail("expected RNFBHandleCollisionException");
+    } catch (RNFBHandleCollisionException e) {
+      assertTrue(e.getMessage().contains("1"));
+      assertSame("first", registry.take(1));
+    }
+  }
+
+  @Test
+  public void take_whenFree_isNull() {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    assertNull(registry.take(99));
+  }
+
+  @Test
+  public void putOrDiscard_storesWhenFree() {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    assertTrue(registry.putOrDiscard(1, "trace"));
+    assertSame("trace", registry.take(1));
+  }
+
+  @Test
+  public void putOrDiscard_collision_dropsIncomingWithoutDiscard() throws Exception {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    registry.put(1, "first");
+    assertFalse(registry.putOrDiscard(1, "second"));
+    assertSame("first", registry.take(1));
+  }
+
+  @Test
+  public void putOrDiscard_collision_nullIncoming_isNoOp() throws Exception {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    registry.put(1, "first");
+    assertFalse(registry.putOrDiscard(1, null));
+    assertSame("first", registry.take(1));
+  }
+
+  @Test
+  public void putReplacing_whenFree_stores() {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    assertNull(registry.putReplacing(1, "trace"));
+    assertSame("trace", registry.get(1));
+  }
+
+  @Test
+  public void putReplacing_whenOccupied_returnsDisplaced() throws Exception {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    registry.put(1, "first");
+    assertSame("first", registry.putReplacing(1, "second"));
+    assertSame("second", registry.get(1));
+  }
+
+  @Test
+  public void putReplacing_moduleCollisionPattern_stopsDisplacedOutsideLock() throws Exception {
+    RNFBPerfHandleRegistry<FakeStoppableHandle> registry = new RNFBPerfHandleRegistry<>();
+    FakeStoppableHandle first = new FakeStoppableHandle();
+    FakeStoppableHandle second = new FakeStoppableHandle();
+    registry.put(1, first);
+    FakeStoppableHandle displaced = registry.putReplacing(1, second);
+    if (displaced != null) {
+      displaced.stop();
+    }
+    assertEquals(1, first.stopCount);
+    assertEquals(0, second.stopCount);
+    assertSame(second, registry.get(1));
+  }
+
+  @Test
+  public void get_whenFree_isNull() {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    assertNull(registry.get(99));
+  }
+
+  @Test
+  public void get_whenOccupied_returnsHandle() throws Exception {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    registry.put(1, "trace");
+    assertSame("trace", registry.get(1));
+    assertSame("trace", registry.take(1));
+  }
+
+  @Test
+  public void takeAll_returnsSnapshotAndLeavesEmpty() throws Exception {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    registry.put(1, "a");
+    registry.put(2, "b");
+    List<String> remaining = registry.takeAll();
+    assertEquals(2, remaining.size());
+    assertTrue(remaining.contains("a"));
+    assertTrue(remaining.contains("b"));
+    assertNull(registry.take(1));
+    assertNull(registry.take(2));
+  }
+
+  @Test
+  public void takeAll_empty_returnsEmptyList() {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    assertTrue(registry.takeAll().isEmpty());
+  }
+
+  @Test
+  public void takeAll_nullHandle_isIncluded() throws Exception {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    registry.put(1, null);
+    List<String> remaining = registry.takeAll();
+    assertEquals(1, remaining.size());
+    assertNull(remaining.get(0));
+  }
+
+  @Test
+  public void put_afterTake_allowsReuse() throws Exception {
+    RNFBPerfHandleRegistry<String> registry = new RNFBPerfHandleRegistry<>();
+    registry.put(1, "first");
+    assertSame("first", registry.take(1));
+    registry.put(1, "second");
+    assertSame("second", registry.take(1));
+  }
+
+  private static final class FakeStoppableHandle {
+    int stopCount = 0;
+
+    void stop() {
+      stopCount++;
+    }
+  }
+}

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

@@ -1,7 +1,7 @@
 import type { FirebaseApp } from '@react-native-firebase/app';
 import './types/internal';
 import type { FirebasePerformance, HttpMetric, HttpMethod, PerformanceSettings, PerformanceTrace, ScreenTrace } from './types/perf';
-export declare const SDK_VERSION = "26.3.3";
+export declare const SDK_VERSION = "26.4.0";
 export declare function getPerformance(app?: FirebaseApp): FirebasePerformance;
 /**
  * Creates a Performance Monitoring instance and applies optional settings.

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/RNFBPerf/RNFBPerfHandleRegistry.h

@@ -0,0 +1,41 @@
+/**
+ * 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
+
+/**
+ * Perf trace / HTTP metric handle map. Module start paths use `putReplacing` (last wins, stop
+ * displaced outside lock). Unique `put` / `putOrDiscard` remain for tests. Callers `get` then
+ * `take` then stop outside the HandleMap lock. Tear-down uses `takeAll` without stopping.
+ */
+@interface RNFBPerfHandleRegistry : NSObject
+
+- (BOOL)put:(id)key value:(id)value error:(NSError *_Nullable *_Nullable)error;
+/// Unique put. On collision, drop the incoming handle without stopping.
+- (BOOL)putOrDiscard:(id)key value:(id)value;
+/// Last wins. Returns the displaced handle, or nil if the key was free.
+- (nullable id)putReplacing:(id)key value:(id)value;
+- (nullable id)get:(id)key;
+- (nullable id)take:(id)key;
+- (nullable id)takeIf:(id)key when:(BOOL (^)(id value))condition;
+- (NSArray *)takeAll;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RNFBPerf/RNFBPerfHandleRegistry.m

@@ -0,0 +1,68 @@
+/**
+ * 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 "RNFBPerfHandleRegistry.h"
+
+#if __has_include("RNFBHandleMap.h")
+#import "RNFBHandleMap.h"
+#else
+#import "RNFBApp/RNFBHandleMap.h"
+#endif
+
+@interface RNFBPerfHandleRegistry ()
+@property(nonatomic, strong) RNFBHandleMap *map;
+@end
+
+@implementation RNFBPerfHandleRegistry
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _map = [[RNFBHandleMap alloc] init];
+  }
+  return self;
+}
+
+- (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 {
+  return [self.map putIfAbsent:key value:value];
+}
+
+- (id)putReplacing:(id)key value:(id)value {
+  return [self.map putReplacing:key value:value];
+}
+
+- (id)get:(id)key {
+  return [self.map get:key];
+}
+
+- (id)take:(id)key {
+  return [self.map take:key];
+}
+
+- (id)takeIf:(id)key when:(BOOL (^)(id))condition {
+  return [self.map takeIf:key when:condition];
+}
+
+- (NSArray *)takeAll {
+  return [self.map takeAll];
+}
+
+@end

package/ios/RNFBPerf/RNFBPerfModule.mm

@@ -35,10 +35,11 @@
 #define RNFB_PERF_SDK_AVAILABLE 0
 #endif
 #import "RNFBApp/RNFBSharedUtils.h"
+#import "RNFBPerfHandleRegistry.h"
 #import "RNFBPerfModule.h"
 
-static __strong NSMutableDictionary *traces;
-static __strong NSMutableDictionary *httpMetrics;
+static RNFBPerfHandleRegistry *traces;
+static RNFBPerfHandleRegistry *httpMetrics;
 
 @implementation RNFBPerfModule
 
@@ -53,23 +54,16 @@ RCT_EXPORT_MODULE(NativeRNFBTurboPerf)
 
   static dispatch_once_t onceToken;
   dispatch_once(&onceToken, ^{
-    traces = [[NSMutableDictionary alloc] init];
-    httpMetrics = [[NSMutableDictionary alloc] init];
+    traces = [[RNFBPerfHandleRegistry alloc] init];
+    httpMetrics = [[RNFBPerfHandleRegistry alloc] init];
   });
 
   return self;
 }
 
 - (void)invalidate {
-  @synchronized([self class]) {
-    for (NSString *key in [traces allKeys]) {
-      [traces removeObjectForKey:key];
-    }
-
-    for (NSString *key in [httpMetrics allKeys]) {
-      [httpMetrics removeObjectForKey:key];
-    }
-  }
+  [traces takeAll];
+  [httpMetrics takeAll];
 }
 
 #if !RNFB_PERF_SDK_AVAILABLE
@@ -141,8 +135,9 @@ RCT_EXPORT_MODULE(NativeRNFBTurboPerf)
   FIRTrace *trace = [[FIRPerformance sharedInstance] traceWithName:identifier];
   [trace start];
 
-  @synchronized([self class]) {
-    traces[@((int)id)] = trace;
+  FIRTrace *displaced = [traces putReplacing:@((int)id) value:trace];
+  if (displaced != nil) {
+    [displaced stop];
   }
 #else
   (void)id;
@@ -152,9 +147,10 @@ RCT_EXPORT_MODULE(NativeRNFBTurboPerf)
 
 - (void)stopTrace:(double)id traceData:(JS::NativeRNFBTurboPerf::TraceData &)traceData {
 #if RNFB_PERF_SDK_AVAILABLE
-  FIRTrace *trace;
-  @synchronized([self class]) {
-    trace = traces[@((int)id)];
+  NSNumber *traceId = @((int)id);
+  FIRTrace *trace = [traces get:traceId];
+  if (trace == nil) {
+    return;
   }
 
   NSDictionary *metrics = (NSDictionary *)traceData.metrics();
@@ -169,10 +165,13 @@ RCT_EXPORT_MODULE(NativeRNFBTurboPerf)
         [trace setValue:value forAttribute:attributeName];
       }];
 
-  [trace stop];
-
-  @synchronized([self class]) {
-    [traces removeObjectForKey:@((int)id)];
+  FIRTrace *expected = trace;
+  trace = [traces takeIf:traceId
+                    when:^BOOL(NSObject *value) {
+                      return value == expected;
+                    }];
+  if (trace != nil) {
+    [trace stop];
   }
 #else
   (void)id;
@@ -215,8 +214,9 @@ RCT_EXPORT_MODULE(NativeRNFBTurboPerf)
   FIRHTTPMetric *httpMetric = [[FIRHTTPMetric alloc] initWithURL:toNSURL HTTPMethod:method];
   [httpMetric start];
 
-  @synchronized([self class]) {
-    httpMetrics[@((int)id)] = httpMetric;
+  FIRHTTPMetric *displaced = [httpMetrics putReplacing:@((int)id) value:httpMetric];
+  if (displaced != nil) {
+    [displaced stop];
   }
 #else
   (void)id;
@@ -227,9 +227,10 @@ RCT_EXPORT_MODULE(NativeRNFBTurboPerf)
 
 - (void)stopHttpMetric:(double)id metricData:(JS::NativeRNFBTurboPerf::HttpMetricData &)metricData {
 #if RNFB_PERF_SDK_AVAILABLE
-  FIRHTTPMetric *httpMetric;
-  @synchronized([self class]) {
-    httpMetric = httpMetrics[@((int)id)];
+  NSNumber *metricId = @((int)id);
+  FIRHTTPMetric *httpMetric = [httpMetrics get:metricId];
+  if (httpMetric == nil) {
+    return;
   }
 
   NSDictionary *attributes = (NSDictionary *)metricData.attributes();
@@ -254,10 +255,13 @@ RCT_EXPORT_MODULE(NativeRNFBTurboPerf)
     [httpMetric setResponseContentType:metricData.responseContentType()];
   }
 
-  [httpMetric stop];
-
-  @synchronized([self class]) {
-    [httpMetrics removeObjectForKey:@((int)id)];
+  FIRHTTPMetric *expected = httpMetric;
+  httpMetric = [httpMetrics takeIf:metricId
+                              when:^BOOL(NSObject *value) {
+                                return value == expected;
+                              }];
+  if (httpMetric != nil) {
+    [httpMetric stop];
   }
 #else
   (void)id;

package/ios/RNFBPerfUnitTests/RNFBPerfHandleRegistryTests.m

@@ -0,0 +1,123 @@
+/**
+ * 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 "RNFBPerfHandleRegistry.h"
+
+@interface FakePerfHandle : NSObject
+@property(nonatomic, assign) NSInteger stopCount;
+- (void)stop;
+@end
+
+@implementation FakePerfHandle
+- (void)stop {
+  self.stopCount += 1;
+}
+@end
+
+@interface RNFBPerfHandleRegistryTests : XCTestCase
+@property(nonatomic, strong) RNFBPerfHandleRegistry *registry;
+@end
+
+@implementation RNFBPerfHandleRegistryTests
+
+- (void)setUp {
+  [super setUp];
+  self.registry = [[RNFBPerfHandleRegistry alloc] init];
+}
+
+- (void)testPutGetTake_happyPath {
+  FakePerfHandle *handle = [[FakePerfHandle alloc] init];
+  NSError *error = nil;
+  XCTAssertTrue([self.registry put:@1 value:handle error:&error]);
+  XCTAssertNil(error);
+  XCTAssertEqual(handle, [self.registry get:@1]);
+  XCTAssertEqual(handle, [self.registry take:@1]);
+  XCTAssertNil([self.registry get:@1]);
+  XCTAssertEqual(handle.stopCount, 0);
+}
+
+- (void)testPut_occupiedId_returnsCollision {
+  FakePerfHandle *first = [[FakePerfHandle alloc] init];
+  XCTAssertTrue([self.registry put:@1 value:first error:nil]);
+
+  NSError *error = nil;
+  XCTAssertFalse([self.registry put:@1 value:[[FakePerfHandle alloc] init] error:&error]);
+  XCTAssertNotNil(error);
+  XCTAssertEqualObjects(error.domain, RNFBHandleMapErrorDomain);
+  XCTAssertEqual(error.code, RNFBHandleMapErrorCollision);
+  XCTAssertEqual(first, [self.registry get:@1]);
+}
+
+- (void)testPutOrDiscard_collision_dropsIncomingWithoutStop {
+  FakePerfHandle *first = [[FakePerfHandle alloc] init];
+  FakePerfHandle *duplicate = [[FakePerfHandle alloc] init];
+  XCTAssertTrue([self.registry put:@1 value:first error:nil]);
+  XCTAssertFalse([self.registry putOrDiscard:@1 value:duplicate]);
+  XCTAssertEqual(duplicate.stopCount, 0);
+  XCTAssertEqual(first.stopCount, 0);
+  XCTAssertEqual(first, [self.registry get:@1]);
+}
+
+- (void)testPutOrDiscard_storesWhenFree {
+  FakePerfHandle *handle = [[FakePerfHandle alloc] init];
+  XCTAssertTrue([self.registry putOrDiscard:@2 value:handle]);
+  XCTAssertEqual(handle, [self.registry get:@2]);
+  XCTAssertEqual(handle.stopCount, 0);
+}
+
+- (void)testPutReplacing_whenOccupied_returnsDisplaced {
+  FakePerfHandle *first = [[FakePerfHandle alloc] init];
+  FakePerfHandle *second = [[FakePerfHandle alloc] init];
+  XCTAssertTrue([self.registry put:@3 value:first error:nil]);
+  XCTAssertEqual(first, [self.registry putReplacing:@3 value:second]);
+  XCTAssertEqual(second, [self.registry get:@3]);
+}
+
+- (void)testPutReplacing_moduleCollisionPattern_stopsDisplacedOutsideLock {
+  FakePerfHandle *first = [[FakePerfHandle alloc] init];
+  FakePerfHandle *second = [[FakePerfHandle alloc] init];
+  XCTAssertTrue([self.registry put:@6 value:first error:nil]);
+  FakePerfHandle *displaced = [self.registry putReplacing:@6 value:second];
+  if (displaced != nil) {
+    [displaced stop];
+  }
+  XCTAssertEqual(first.stopCount, 1);
+  XCTAssertEqual(second.stopCount, 0);
+  XCTAssertEqual(second, [self.registry get:@6]);
+}
+
+- (void)testTakeAll_returnsSnapshotAndLeavesEmpty {
+  FakePerfHandle *a = [[FakePerfHandle alloc] init];
+  FakePerfHandle *b = [[FakePerfHandle alloc] init];
+  XCTAssertTrue([self.registry put:@4 value:a error:nil]);
+  XCTAssertTrue([self.registry put:@5 value:b error:nil]);
+  NSArray *remaining = [self.registry takeAll];
+  XCTAssertEqual(remaining.count, 2);
+  XCTAssertNil([self.registry get:@4]);
+  XCTAssertNil([self.registry get:@5]);
+  XCTAssertEqual(a.stopCount, 0);
+  XCTAssertEqual(b.stopCount, 0);
+}
+
+- (void)testGet_whenFree_isNil {
+  XCTAssertNil([self.registry get:@99]);
+}
+
+@end

package/ios/RNFBPerfUnitTests/RNFBPerfUnitTests.xcodeproj/project.pbxproj

@@ -0,0 +1,251 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 56;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		B9000000000000000000000A /* RNFBHandleMap.m in Sources */ = {isa = PBXBuildFile; fileRef = B90000000000000000000008 /* RNFBHandleMap.m */; };
+		B9000000000000000000000B /* RNFBPerfHandleRegistry.m in Sources */ = {isa = PBXBuildFile; fileRef = B90000000000000000000018 /* RNFBPerfHandleRegistry.m */; };
+		B9000000000000000000000C /* RNFBPerfHandleRegistryTests.m in Sources */ = {isa = PBXBuildFile; fileRef = B90000000000000000000009 /* RNFBPerfHandleRegistryTests.m */; };
+		B90000000000000000000015 /* XCTest.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B90000000000000000000014 /* XCTest.framework */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		B90000000000000000000003 /* RNFBPerfUnitTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RNFBPerfUnitTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+		B90000000000000000000007 /* RNFBHandleMap.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RNFBHandleMap.h; path = ../../../app/ios/RNFBApp/RNFBHandleMap.h; sourceTree = SOURCE_ROOT; };
+		B90000000000000000000008 /* RNFBHandleMap.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = RNFBHandleMap.m; path = ../../../app/ios/RNFBApp/RNFBHandleMap.m; sourceTree = SOURCE_ROOT; };
+		B90000000000000000000009 /* RNFBPerfHandleRegistryTests.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNFBPerfHandleRegistryTests.m; sourceTree = "<group>"; };
+		B90000000000000000000016 /* RNFBPerfHandleRegistry.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RNFBPerfHandleRegistry.h; path = ../RNFBPerf/RNFBPerfHandleRegistry.h; sourceTree = SOURCE_ROOT; };
+		B90000000000000000000018 /* RNFBPerfHandleRegistry.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = RNFBPerfHandleRegistry.m; path = ../RNFBPerf/RNFBPerfHandleRegistry.m; sourceTree = SOURCE_ROOT; };
+		B90000000000000000000014 /* 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 */
+		B9000000000000000000000D /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				B90000000000000000000015 /* XCTest.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		B90000000000000000000004 = {
+			isa = PBXGroup;
+			children = (
+				B90000000000000000000006 /* Sources */,
+				B90000000000000000000005 /* Products */,
+			);
+			sourceTree = "<group>";
+		};
+		B90000000000000000000005 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				B90000000000000000000003 /* RNFBPerfUnitTests.xctest */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		B90000000000000000000006 /* Sources */ = {
+			isa = PBXGroup;
+			children = (
+				B90000000000000000000007 /* RNFBHandleMap.h */,
+				B90000000000000000000008 /* RNFBHandleMap.m */,
+				B90000000000000000000016 /* RNFBPerfHandleRegistry.h */,
+				B90000000000000000000018 /* RNFBPerfHandleRegistry.m */,
+				B90000000000000000000009 /* RNFBPerfHandleRegistryTests.m */,
+			);
+			name = Sources;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		B90000000000000000000002 /* RNFBPerfUnitTests */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = B90000000000000000000013 /* Build configuration list for PBXNativeTarget "RNFBPerfUnitTests" */;
+			buildPhases = (
+				B9000000000000000000000E /* Sources */,
+				B9000000000000000000000D /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = RNFBPerfUnitTests;
+			productName = RNFBPerfUnitTests;
+			productReference = B90000000000000000000003 /* RNFBPerfUnitTests.xctest */;
+			productType = "com.apple.product-type.bundle.unit-test";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		B90000000000000000000001 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				BuildIndependentTargetsInParallel = 1;
+				LastUpgradeCheck = 2600;
+				ORGANIZATIONNAME = Invertase;
+				TargetAttributes = {
+					B90000000000000000000002 = {
+						CreatedOnToolsVersion = 26.0;
+					};
+				};
+			};
+			buildConfigurationList = B90000000000000000000012 /* Build configuration list for PBXProject "RNFBPerfUnitTests" */;
+			compatibilityVersion = "Xcode 14.0";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = B90000000000000000000004;
+			productRefGroup = B90000000000000000000005 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				B90000000000000000000002 /* RNFBPerfUnitTests */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		B9000000000000000000000E /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				B9000000000000000000000A /* RNFBHandleMap.m in Sources */,
+				B9000000000000000000000B /* RNFBPerfHandleRegistry.m in Sources */,
+				B9000000000000000000000C /* RNFBPerfHandleRegistryTests.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		B9000000000000000000001A /* 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;
+		};
+		B9000000000000000000001B /* 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;
+		};
+		B90000000000000000000010 /* 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)/../RNFBPerf",
+				);
+				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.RNFBPerfUnitTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = macosx;
+				SUPPORTED_PLATFORMS = macosx;
+			};
+			name = Debug;
+		};
+		B90000000000000000000011 /* 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)/../RNFBPerf",
+				);
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/../Frameworks",
+					"@loader_path/../Frameworks",
+				);
+				MACOSX_DEPLOYMENT_TARGET = 14.0;
+				PRODUCT_BUNDLE_IDENTIFIER = io.invertase.firebase.RNFBPerfUnitTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = macosx;
+				SUPPORTED_PLATFORMS = macosx;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		B90000000000000000000012 /* Build configuration list for PBXProject "RNFBPerfUnitTests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				B9000000000000000000001A /* Debug */,
+				B9000000000000000000001B /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+		B90000000000000000000013 /* Build configuration list for PBXNativeTarget "RNFBPerfUnitTests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				B90000000000000000000010 /* Debug */,
+				B90000000000000000000011 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = B90000000000000000000001 /* Project object */;
+}

package/ios/RNFBPerfUnitTests/RNFBPerfUnitTests.xcodeproj/xcshareddata/xcschemes/RNFBPerfUnitTests.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 = "B90000000000000000000002"
+               BuildableName = "RNFBPerfUnitTests.xctest"
+               BlueprintName = "RNFBPerfUnitTests"
+               ReferencedContainer = "container:RNFBPerfUnitTests.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 = "B90000000000000000000002"
+               BuildableName = "RNFBPerfUnitTests.xctest"
+               BlueprintName = "RNFBPerfUnitTests"
+               ReferencedContainer = "container:RNFBPerfUnitTests.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/perf",
-  "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 Performance Monitoring to gain insight into key performance characteristics within your React Native application.",
   "main": "./dist/module/index.js",
@@ -30,6 +30,7 @@
     "android:codegen": "node ../../scripts/codegen-package.mjs perf android",
     "ios:codegen": "node ../../scripts/codegen-package.mjs perf ios"
   },
+  "homepage": "https://rnfirebase.io",
   "repository": {
     "type": "git",
     "url": "https://github.com/invertase/react-native-firebase",
@@ -48,11 +49,11 @@
     "performance monitoring"
   ],
   "peerDependencies": {
-    "@react-native-firebase/app": "26.3.3",
+    "@react-native-firebase/app": "26.4.0",
     "expo": ">=47.0.0"
   },
   "devDependencies": {
-    "@react-native-firebase/app": "26.3.3",
+    "@react-native-firebase/app": "26.4.0",
     "expo": "^55.0.18",
     "react-native-builder-bob": "^0.40.13"
   },
@@ -103,5 +104,5 @@
     "node_modules/",
     "dist/"
   ],
-  "gitHead": "04b90008385bf69be74f3a333d0dfea43ba32e64"
+  "gitHead": "06701af5fdc19bae9f379567eadb29dfe81953c0"
 }