@react-native-firebase/crashlytics 26.4.0 → 27.0.0

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [27.0.0](https://github.com/invertase/react-native-firebase/compare/v26.4.0...v27.0.0) (2026-10-19)
+
+### ⚠ BREAKING CHANGES
+
+- **app, sdk:** bump Firebase Android 35, Apple 13, and JS 13
+
+### Features
+
+- **app, sdk:** bump Firebase Android 35, Apple 13, and JS 13 ([0ca03d1](https://github.com/invertase/react-native-firebase/commit/0ca03d11b0c271fb37cfbee8a0c3074a21969f0b))
+- **test-expo:** add Expo Router example with a route per package ([#9313](https://github.com/invertase/react-native-firebase/issues/9313)) ([50a946a](https://github.com/invertase/react-native-firebase/commit/50a946ab4f6c11670890940b55e8bb71f6332dcf))
+
+### Bug Fixes
+
+- **crashlytics, ios:** resolve target-folder GoogleService-Info.plist for SPM dSYM upload ([a2b7e57](https://github.com/invertase/react-native-firebase/commit/a2b7e5789b6df07d3aa2729f734582de6a5feb92)), closes [#9304](https://github.com/invertase/react-native-firebase/issues/9304)
+
 ## [26.4.0](https://github.com/invertase/react-native-firebase/compare/v26.3.3...v26.4.0) (2026-09-05)
 
 **Note:** Version bump only for package @react-native-firebase/crashlytics

package/RNFBCrashlytics.podspec

@@ -32,8 +32,14 @@ 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.*'
+  # CocoaPods FileList uses FNM_PATHNAME: `ios/*UnitTests/**` does not match nested
+  # files under HostStubs; use `ios/*UnitTests/**/*` (same as sibling packages).
+  s.exclude_files       = 'ios/generated/RCTThirdPartyComponentsProvider.*', 'ios/generated/RCTAppDependencyProvider.*', 'ios/generated/RCTModuleProviders.*', 'ios/generated/RCTModulesConformingToProtocolsProvider.*', 'ios/generated/RCTUnstableModulesRequiringMainQueueSetupProvider.*', 'ios/*UnitTests/**/*'
+  s.swift_version       = '5.10'
+
+  # DEFINES_MODULE is required for the generated RNFBCrashlytics-Swift.h interface.
   s.pod_target_xcconfig = {
+    "DEFINES_MODULE" => "YES",
     "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/ios/generated/RNFBCrashlyticsTurboModules\" \"$(PODS_TARGET_SRCROOT)/ios/generated\"",
     "CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES" => "YES",
   }

package/android/build.gradle

@@ -13,6 +13,7 @@ buildscript {
 
     dependencies {
       classpath("com.android.tools.build:gradle:8.4.0")
+      classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.findProperty('kotlinVersion') ?: '2.4.0'}")
     }
   }
 }
@@ -21,6 +22,8 @@ plugins {
   id "io.invertase.gradle.build" version "1.5"
 }
 
+apply plugin: "org.jetbrains.kotlin.android"
+
 def appProject
 if (findProject(':@react-native-firebase_app')) {
   appProject = project(':@react-native-firebase_app')
@@ -99,6 +102,10 @@ dependencies {
   implementation platform("com.google.firebase:firebase-bom:${ReactNative.ext.getVersion("firebase", "bom")}")
   implementation "com.google.firebase:firebase-crashlytics"
   implementation "com.google.firebase:firebase-crashlytics-ndk"
+
+  testImplementation "junit:junit:4.13.2"
+  testImplementation "org.robolectric:robolectric:4.14.1"
+  testImplementation "org.mockito:mockito-core:5.14.2"
 }
 
 ReactNative.shared.applyPackageVersion()

package/android/src/main/java/io/invertase/firebase/crashlytics/Constants.kt

@@ -0,0 +1,42 @@
+package io.invertase.firebase.crashlytics
+
+/*
+ * 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.
+ *
+ */
+
+/**
+ * Preference / meta / JSON keys for Crashlytics init. Historical Java shape was a
+ * package-private class of `static final String` fields; Kotlin [object] + `@JvmField`
+ * keeps `import static …Constants.*` and `Constants.KEY_…` working for same-module Java.
+ */
+internal object Constants {
+  @JvmField
+  val KEY_CRASHLYTICS_NDK_ENABLED: String = "crashlytics_ndk_enabled"
+
+  @JvmField
+  val KEY_CRASHLYTICS_DEBUG_ENABLED: String = "crashlytics_debug_enabled"
+
+  @JvmField
+  val KEY_CRASHLYTICS_AUTO_COLLECTION_ENABLED: String = "crashlytics_auto_collection_enabled"
+
+  @JvmField
+  val KEY_CRASHLYTICS_IS_ERROR_GENERATION_ON_JS_CRASH_ENABLED: String =
+    "crashlytics_is_error_generation_on_js_crash_enabled"
+
+  @JvmField
+  val KEY_CRASHLYTICS_JAVASCRIPT_EXCEPTION_HANDLER_CHAINING_ENABLED: String =
+    "crashlytics_javascript_exception_handler_chaining_enabled"
+}

package/android/src/main/java/io/invertase/firebase/crashlytics/{JavaScriptError.java → JavaScriptError.kt}

@@ -1,4 +1,4 @@
-package io.invertase.firebase.crashlytics;
+package io.invertase.firebase.crashlytics
 
 /*
  * Copyright (c) 2016-present Invertase Limited & Contributors
@@ -21,8 +21,6 @@ package io.invertase.firebase.crashlytics;
  * This class is purely cosmetic - to indicate on the Crashlytics console that it's a JavaScript
  * error rather than the generic `java.lang.Exception`.
  */
-class JavaScriptError extends Exception {
-  JavaScriptError(String message) {
-    super(message);
-  }
-}
+internal class JavaScriptError(
+  message: String,
+) : Exception(message)

package/android/src/main/java/io/invertase/firebase/crashlytics/ReactNativeFirebaseCrashlyticsNativeHelper.kt

@@ -0,0 +1,45 @@
+package io.invertase.firebase.crashlytics
+
+/*
+ * 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 com.google.firebase.crashlytics.FirebaseCrashlytics
+
+/**
+ * Public static helpers for native/Android callers that need Crashlytics without going through the
+ * TurboModule. Historical Java shape was a class of static methods; Kotlin [object] + `@JvmStatic`
+ * keeps `ReactNativeFirebaseCrashlyticsNativeHelper.recordNativeException(...)` working for Java.
+ */
+object ReactNativeFirebaseCrashlyticsNativeHelper {
+  @JvmStatic
+  fun recordNativeException(throwable: Throwable) {
+    FirebaseCrashlytics.getInstance().recordException(throwable)
+  }
+
+  @JvmStatic
+  fun log(message: String) {
+    FirebaseCrashlytics.getInstance().log(message)
+  }
+
+  @JvmStatic
+  fun setCustomKey(
+    key: String,
+    value: String,
+  ) {
+    FirebaseCrashlytics.getInstance().setCustomKey(key, value)
+  }
+}

package/android/src/main/java/io/invertase/firebase/crashlytics/{UnhandledPromiseRejection.java → UnhandledPromiseRejection.kt}

@@ -1,4 +1,4 @@
-package io.invertase.firebase.crashlytics;
+package io.invertase.firebase.crashlytics
 
 /*
  * Copyright (c) 2016-present Invertase Limited & Contributors
@@ -21,8 +21,6 @@ package io.invertase.firebase.crashlytics;
  * This class is purely cosmetic - to indicate on the Crashlytics console that it's an
  * UnhandledPromiseRejection JS error rather than the generic `java.lang.Exception`.
  */
-class UnhandledPromiseRejection extends Exception {
-  UnhandledPromiseRejection(String message) {
-    super(message);
-  }
-}
+internal class UnhandledPromiseRejection(
+  message: String,
+) : Exception(message)

package/android/src/test/java/io/invertase/firebase/crashlytics/ConstantsAndJsErrorTypesTest.java

@@ -0,0 +1,84 @@
+package io.invertase.firebase.crashlytics;
+
+/*
+ * 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 io.invertase.firebase.crashlytics.Constants.KEY_CRASHLYTICS_AUTO_COLLECTION_ENABLED;
+import static io.invertase.firebase.crashlytics.Constants.KEY_CRASHLYTICS_DEBUG_ENABLED;
+import static io.invertase.firebase.crashlytics.Constants.KEY_CRASHLYTICS_IS_ERROR_GENERATION_ON_JS_CRASH_ENABLED;
+import static io.invertase.firebase.crashlytics.Constants.KEY_CRASHLYTICS_JAVASCRIPT_EXCEPTION_HANDLER_CHAINING_ENABLED;
+import static io.invertase.firebase.crashlytics.Constants.KEY_CRASHLYTICS_NDK_ENABLED;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import org.junit.Test;
+
+/**
+ * JVM coverage for Kotlin-ported {@link Constants}, {@link JavaScriptError}, and {@link
+ * UnhandledPromiseRejection}. Asserts preference-key string values, Java static-field shape for
+ * InitProvider static imports, and cosmetic Crashlytics console type names.
+ */
+public class ConstantsAndJsErrorTypesTest {
+
+  @Test
+  public void constants_stringValuesMatchExpectedKeys() {
+    assertEquals("crashlytics_ndk_enabled", KEY_CRASHLYTICS_NDK_ENABLED);
+    assertEquals("crashlytics_debug_enabled", KEY_CRASHLYTICS_DEBUG_ENABLED);
+    assertEquals("crashlytics_auto_collection_enabled", KEY_CRASHLYTICS_AUTO_COLLECTION_ENABLED);
+    assertEquals(
+        "crashlytics_is_error_generation_on_js_crash_enabled",
+        KEY_CRASHLYTICS_IS_ERROR_GENERATION_ON_JS_CRASH_ENABLED);
+    assertEquals(
+        "crashlytics_javascript_exception_handler_chaining_enabled",
+        KEY_CRASHLYTICS_JAVASCRIPT_EXCEPTION_HANDLER_CHAINING_ENABLED);
+  }
+
+  @Test
+  public void constants_fieldsArePublicStaticForJavaStaticImport() throws Exception {
+    String[] names = {
+      "KEY_CRASHLYTICS_NDK_ENABLED",
+      "KEY_CRASHLYTICS_DEBUG_ENABLED",
+      "KEY_CRASHLYTICS_AUTO_COLLECTION_ENABLED",
+      "KEY_CRASHLYTICS_IS_ERROR_GENERATION_ON_JS_CRASH_ENABLED",
+      "KEY_CRASHLYTICS_JAVASCRIPT_EXCEPTION_HANDLER_CHAINING_ENABLED",
+    };
+    for (String name : names) {
+      Field field = Constants.class.getField(name);
+      int modifiers = field.getModifiers();
+      assertTrue(name, Modifier.isPublic(modifiers));
+      assertTrue(name, Modifier.isStatic(modifiers));
+      assertTrue(name, Modifier.isFinal(modifiers));
+      assertEquals(name, String.class, field.getType());
+    }
+  }
+
+  @Test
+  public void javaScriptError_constructsWithMessageAndCosmeticSimpleName() {
+    JavaScriptError error = new JavaScriptError("js-boom");
+    assertEquals("js-boom", error.getMessage());
+    assertEquals("JavaScriptError", error.getClass().getSimpleName());
+  }
+
+  @Test
+  public void unhandledPromiseRejection_constructsWithMessageAndCosmeticSimpleName() {
+    UnhandledPromiseRejection error = new UnhandledPromiseRejection("promise-boom");
+    assertEquals("promise-boom", error.getMessage());
+    assertEquals("UnhandledPromiseRejection", error.getClass().getSimpleName());
+  }
+}

package/android/src/test/java/io/invertase/firebase/crashlytics/ReactNativeFirebaseCrashlyticsNativeHelperTest.java

@@ -0,0 +1,108 @@
+package io.invertase.firebase.crashlytics;
+
+/*
+ * 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.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.verify;
+
+import com.google.firebase.crashlytics.FirebaseCrashlytics;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.MockedStatic;
+import org.robolectric.RobolectricTestRunner;
+
+/**
+ * JVM coverage for {@link ReactNativeFirebaseCrashlyticsNativeHelper}. Stubs {@link
+ * FirebaseCrashlytics#getInstance()} via mockito-mockstatic so the helper can be exercised without
+ * initializing the Firebase SDK. Robolectric supplies an Android runtime for Firebase class
+ * loading; AndroidTest-AD-1.
+ */
+@RunWith(RobolectricTestRunner.class)
+public class ReactNativeFirebaseCrashlyticsNativeHelperTest {
+
+  @Test
+  public void javaStaticShapePreservedForNativeCallers() throws Exception {
+    assertTrue(Modifier.isPublic(ReactNativeFirebaseCrashlyticsNativeHelper.class.getModifiers()));
+    assertTrue(Modifier.isFinal(ReactNativeFirebaseCrashlyticsNativeHelper.class.getModifiers()));
+    assertSame(
+        ReactNativeFirebaseCrashlyticsNativeHelper.INSTANCE,
+        ReactNativeFirebaseCrashlyticsNativeHelper.INSTANCE);
+
+    Method record =
+        ReactNativeFirebaseCrashlyticsNativeHelper.class.getMethod(
+            "recordNativeException", Throwable.class);
+    Method log = ReactNativeFirebaseCrashlyticsNativeHelper.class.getMethod("log", String.class);
+    Method setCustomKey =
+        ReactNativeFirebaseCrashlyticsNativeHelper.class.getMethod(
+            "setCustomKey", String.class, String.class);
+
+    for (Method method : Arrays.asList(record, log, setCustomKey)) {
+      assertTrue(method.getName(), Modifier.isStatic(method.getModifiers()));
+      assertTrue(method.getName(), Modifier.isPublic(method.getModifiers()));
+    }
+  }
+
+  @Test
+  public void recordNativeException_forwardsToFirebaseCrashlytics() {
+    FirebaseCrashlytics crashlytics = mock(FirebaseCrashlytics.class);
+    Throwable throwable = new RuntimeException("native-boom");
+
+    try (MockedStatic<FirebaseCrashlytics> firebaseCrashlytics =
+        mockStatic(FirebaseCrashlytics.class)) {
+      firebaseCrashlytics.when(FirebaseCrashlytics::getInstance).thenReturn(crashlytics);
+
+      ReactNativeFirebaseCrashlyticsNativeHelper.recordNativeException(throwable);
+
+      verify(crashlytics).recordException(throwable);
+    }
+  }
+
+  @Test
+  public void log_forwardsToFirebaseCrashlytics() {
+    FirebaseCrashlytics crashlytics = mock(FirebaseCrashlytics.class);
+
+    try (MockedStatic<FirebaseCrashlytics> firebaseCrashlytics =
+        mockStatic(FirebaseCrashlytics.class)) {
+      firebaseCrashlytics.when(FirebaseCrashlytics::getInstance).thenReturn(crashlytics);
+
+      ReactNativeFirebaseCrashlyticsNativeHelper.log("native-log");
+
+      verify(crashlytics).log("native-log");
+    }
+  }
+
+  @Test
+  public void setCustomKey_forwardsToFirebaseCrashlytics() {
+    FirebaseCrashlytics crashlytics = mock(FirebaseCrashlytics.class);
+
+    try (MockedStatic<FirebaseCrashlytics> firebaseCrashlytics =
+        mockStatic(FirebaseCrashlytics.class)) {
+      firebaseCrashlytics.when(FirebaseCrashlytics::getInstance).thenReturn(crashlytics);
+
+      ReactNativeFirebaseCrashlyticsNativeHelper.setCustomKey("k", "v");
+
+      verify(crashlytics).setCustomKey("k", "v");
+    }
+  }
+}

package/dist/module/version.js

@@ -1,5 +1,5 @@
 "use strict";
 
 // Generated by genversion.
-export const version = '26.4.0';
+export const version = '27.0.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 { Crashlytics } from './types/crashlytics';
-export declare const SDK_VERSION = "26.4.0";
+export declare const SDK_VERSION = "27.0.0";
 export declare function getCrashlytics(app?: FirebaseApp): Crashlytics;
 export declare function checkForUnsentReports(crashlytics: Crashlytics): Promise<boolean>;
 export declare function deleteUnsentReports(crashlytics: Crashlytics): Promise<void>;

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

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

package/ios/RNFBCrashlytics/RNFBCrashlyticsDebuggerProbe.swift

@@ -0,0 +1,121 @@
+/**
+ * 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 Darwin
+import Foundation
+
+/**
+ * Debugger-attach detection previously inline in `RNFBCrashlyticsModule.mm`
+ * (`-isDebuggerAttached`).
+ *
+ * Pre-port contracts:
+ * - Once-token / dispatch_once-style caching of the result
+ * - `sysctl` `CTL_KERN` / `KERN_PROC` / `KERN_PROC_PID` / `getpid()` → `kinfo_proc`
+ * - `sysctl` failure → ELog-equivalent + treat as not attached (then still evaluate
+ *   `P_TRACED` on the returned buffer, matching the pre-port control flow)
+ * - `P_TRACED` bit set → true
+ *
+ * Foundation + Darwin only so unit tests do not link Firebase / React.
+ */
+@objc(RNFBCrashlyticsDebuggerProbe)
+public final class RNFBCrashlyticsDebuggerProbe: NSObject {
+
+  /// Injectable `sysctl` seam for unit tests. Production uses `makeDefaultSysctl()`.
+  typealias SysctlProbe = (
+    _ name: UnsafeMutablePointer<Int32>,
+    _ namelen: u_int,
+    _ oldp: UnsafeMutableRawPointer?,
+    _ oldlenp: UnsafeMutablePointer<Int>,
+    _ newp: UnsafeMutableRawPointer?,
+    _ newlen: Int
+  ) -> Int32
+
+  private static let lock = NSLock()
+  private static var cachedResult: Bool?
+  /// Mirrors `static dispatch_once_t` — evaluate at most once in production path.
+  private static var onceTokenConsumed = false
+
+  /// Test hook: replace `sysctl`. Restored by `resetForTesting()`.
+  static var sysctlImpl: SysctlProbe = makeDefaultSysctl()
+
+  private static func makeDefaultSysctl() -> SysctlProbe {
+    { name, namelen, oldp, oldlenp, newp, newlen in
+      Darwin.sysctl(name, namelen, oldp, oldlenp, newp, newlen)
+    }
+  }
+
+  /// Pre-port `-isDebuggerAttached` (once-cached).
+  @objc
+  public static func isDebuggerAttached() -> Bool {
+    lock.lock()
+    defer { lock.unlock() }
+    if onceTokenConsumed, let cached = cachedResult {
+      return cached
+    }
+    let value = evaluateIsDebuggerAttached(using: sysctlImpl)
+    cachedResult = value
+    onceTokenConsumed = true
+    return value
+  }
+
+  /// Clears once-cache and restores the default `sysctl` implementation (tests only).
+  static func resetForTesting() {
+    lock.lock()
+    defer { lock.unlock() }
+    cachedResult = nil
+    onceTokenConsumed = false
+    sysctlImpl = makeDefaultSysctl()
+  }
+
+  /// Evaluates without consuming the production once-cache (tests only).
+  static func evaluateUncachedForTesting(using probe: SysctlProbe) -> Bool {
+    evaluateIsDebuggerAttached(using: probe)
+  }
+
+  /// Core logic matching the pre-port `dispatch_once` body.
+  private static func evaluateIsDebuggerAttached(using probe: SysctlProbe) -> Bool {
+    var debuggerIsAttached = false
+
+    var info = kinfo_proc()
+    var infoSize = MemoryLayout<kinfo_proc>.size
+    var name: [Int32] = [
+      CTL_KERN,
+      KERN_PROC,
+      KERN_PROC_PID,
+      getpid(),
+    ]
+
+    // `name` is always 4 elements — `baseAddress` is non-nil.
+    let sysctlResult = name.withUnsafeMutableBufferPointer { nameBuf -> Int32 in
+      probe(nameBuf.baseAddress!, 4, &info, &infoSize, nil, 0)
+    }
+
+    if sysctlResult == -1 {
+      // ELog is NSLog with function/line prefix (RNFBSharedUtils.h).
+      let err = String(cString: strerror(errno))
+      NSLog(
+        "%@ [Line %d] Crashlytics ERROR: Checking for a running debugger via sysctl() failed: %@",
+        #function, #line, err)
+      debuggerIsAttached = false
+    }
+
+    if !debuggerIsAttached && (info.kp_proc.p_flag & P_TRACED) != 0 {
+      debuggerIsAttached = true
+    }
+
+    return debuggerIsAttached
+  }
+}

package/ios/RNFBCrashlytics/RNFBCrashlyticsHelper.h

@@ -0,0 +1,58 @@
+/**
+ * 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>
+
+// Plain Objective-C helper (see docs/ios-spm.mdx and
+// okf-bundle/ios-spm-native-imports.md) that owns every call touching
+// `FIRCrashlytics` / exception models for RNFBCrashlyticsModule, plus the
+// Swift debugger probe. This keeps RNFBCrashlyticsModule.mm free of Firebase
+// Crashlytics imports and `*-Swift.h`: under SPM an Objective-C++ (.mm)
+// TurboModule cannot `@import` Firebase (or parse a Swift-generated header
+// that uses module imports) when C++ modules are disabled (required by React
+// Native's JSI headers).
+@interface RNFBCrashlyticsHelper : NSObject
+
+/** Cached `sysctl` debugger-attach probe (Swift `RNFBCrashlyticsDebuggerProbe`). */
++ (BOOL)isDebuggerAttached;
+
++ (void)checkForUnsentReportsWithCompletion:(void (^)(BOOL unsentReports))completion;
+
++ (void)deleteUnsentReports;
+
++ (BOOL)didCrashDuringPreviousExecution;
+
++ (void)log:(NSString *)message;
+
++ (void)sendUnsentReports;
+
++ (void)setCustomValue:(NSString *)value forKey:(NSString *)key;
+
+/** Applies each entry via `setCustomValue:forKey:` (Module setAttributes path). */
++ (void)setCustomKeysAndValues:(NSDictionary *)attributes;
+
++ (void)setUserID:(NSString *)userId;
+
+/**
+ * Records a JS exception model.
+ * Each frame dictionary uses keys: `fn` (symbol), `file`, `line` (number).
+ */
++ (void)recordJavaScriptErrorWithMessage:(NSString *)message
+                                  frames:(NSArray<NSDictionary *> *)frames
+             isUnhandledPromiseRejection:(BOOL)isUnhandledPromiseRejection;
+
+@end