@react-native-firebase/app 26.3.2 → 26.4.0

package/firebase_spm.rb

@@ -313,10 +313,11 @@ end
 # release restructures `Pod::Installer`), it prints a `pod install`-time
 # warning telling you to call this explicitly instead:
 #
-#   post_install do |installer|
-#     react_native_post_install(installer, ...)
+#   post_integrate do |installer|
 #     rnfirebase_add_spm_embed_phase(installer)
 #   end
+#
+# Use `post_install` only if your CocoaPods version has no `post_integrate`.
 def rnfirebase_add_spm_embed_phase(installer)
   return unless RNFirebaseSPM.active?
 
@@ -386,7 +387,7 @@ def rnfirebase_verify_spm_embed_phase_applied!(installer)
 
     Without it, this app will crash at launch with a missing-library dyld error, because Firebase's Swift Package frameworks never get copied into the app bundle.
 
-    Add `rnfirebase_add_spm_embed_phase(installer)` to your Podfile's post_install block as a fallback, then run `pod install` again. # rubocop:disable Layout/LineLength
+    Add `rnfirebase_add_spm_embed_phase(installer)` to your Podfile's post_integrate block as a fallback, then run `pod install` again. # rubocop:disable Layout/LineLength
   MESSAGE
 end
 
@@ -444,6 +445,41 @@ def rnfirebase_fail_if_spm_static_linkage!(installer)
   MESSAGE
 end
 
+# Expo's precompiled-module pre-install hook runs after Podfile pre-install
+# hooks and changes React-Core-dependent pod targets to static libraries.
+# That is required for Expo's own source-built pods, but RNFB's Firebase SPM
+# products are automatic libraries: making more than one RNFB pod static
+# absorbs the same Firebase objects into each archive and the app link fails
+# with duplicate symbols.
+#
+# Restore only Expo's generated prebuilt-RNCore + dynamic-framework path, and
+# only RNFB targets that Expo actually changed to `static_library`. Bare
+# consumers never define `Expo::PrecompiledModules`; source-built Expo installs
+# make `enabled?` false; static/no-framework Podfiles do not report `:dynamic`.
+# Existing dynamic RNFB targets and explicit static frameworks are untouched.
+def rnfirebase_restore_dynamic_linkage_after_expo_prebuilt!(installer)
+  return unless RNFirebaseSPM.active?
+  return unless defined?(Expo::PrecompiledModules)
+  return unless Expo::PrecompiledModules.respond_to?(:enabled?) &&
+                Expo::PrecompiledModules.respond_to?(:linkage)
+  return unless Expo::PrecompiledModules.enabled?
+  return unless Expo::PrecompiledModules.linkage(installer) == :dynamic
+
+  static_library = Pod::BuildType.static_library
+  dynamic_framework = Pod::BuildType.dynamic_framework
+  restored_targets = installer.pod_targets.select do |target|
+    target.name.start_with?('RNFB') && target.build_type == static_library
+  end
+
+  restored_targets.each do |target|
+    target.define_singleton_method(:build_type) { dynamic_framework }
+  end
+  return if restored_targets.empty? || !defined?(Pod::UI)
+
+  names = restored_targets.map(&:name).join(', ')
+  Pod::UI.puts "[react-native-firebase] Restored dynamic framework linkage after Expo prebuilt downgrade: #{names}"
+end
+
 # CocoaPods `TargetUUIDGenerator` replaces `@generated_uuids` with leftover
 # `@available_uuids` before Podfile `post_install`. RN's SPM integration then
 # calls `project.new` for Firebase package product deps; with an empty/short
@@ -527,19 +563,103 @@ end
 # runs automatically on every `pod install`/`pod update`, without requiring
 # any Podfile change from consumers.
 #
-# We wrap `Pod::Installer#run_podfile_post_install_hooks` -- the method
-# CocoaPods calls, unconditionally, on every install (it's what runs the
-# Podfile's own `post_install do |installer| ... end` block, if any, but the
-# *wrapper* method itself always runs even when the Podfile defines no
-# `post_install` at all). This is the same point in the install lifecycle
-# where consumers previously called `rnfirebase_add_spm_embed_phase`
-# manually, so behavior is unchanged -- only *how* it gets invoked differs.
+# User-project SPM mutations (embed phase, FirebaseCore on the app target,
+# signature workaround, build settings). Must run *after* CocoaPods has
+# integrated `[CP] Embed Pods Frameworks` into the app target -- see
+# `rnfirebase_hook_cocoapods_post_install!`. Extracted so both the
+# `post_integrate` hook (current CocoaPods) and the `post_install` fallback
+# (older CocoaPods without `run_podfile_post_integrate_hooks`) share one body.
+def rnfirebase_run_spm_user_project_hooks(installer)
+  begin
+    rnfirebase_add_spm_embed_phase(installer)
+  rescue StandardError => e
+    if defined?(Pod::UI)
+      Pod::UI.warn "[react-native-firebase] Couldn't embed Firebase SPM frameworks " \
+                   "automatically (#{e.class}: #{e.message}). Add `rnfirebase_add_spm_embed_phase(installer)` " \
+                   'to your Podfile\'s post_integrate block as a fallback.'
+    end
+  end
+  # Deliberately outside the `rescue` above: dynamic framework embedding is
+  # load-bearing (without it, the app crashes at launch with a missing-library
+  # dyld error), so if the phase still isn't on a target that needs it --
+  # whether the call raised, silently no-opped, or only partially applied --
+  # this must abort `pod install` rather than let a broken install continue.
+  rnfirebase_verify_spm_embed_phase_applied!(installer)
+  begin
+    rnfirebase_add_spm_core_to_app_target(installer)
+  rescue StandardError => e
+    if defined?(Pod::UI)
+      Pod::UI.warn "[react-native-firebase] Couldn't link FirebaseCore into the app target " \
+                   "automatically (#{e.class}: #{e.message}). " \
+                   'Add `rnfirebase_add_spm_core_to_app_target(installer)` ' \
+                   'to your Podfile\'s post_integrate block as a fallback if your own native code calls ' \
+                   'FIRApp/FIROptions APIs directly.'
+    end
+  end
+  begin
+    rnfirebase_remove_spm_core_from_app_target(installer)
+  rescue StandardError => e
+    if defined?(Pod::UI)
+      Pod::UI.warn "[react-native-firebase] Couldn't remove a stale FirebaseCore SPM link from the " \
+                   "app target automatically (#{e.class}: #{e.message}). If you previously used SPM and have " \
+                   'since set `$RNFirebaseDisableSPM = true`, remove the "firebase-ios-sdk" Swift Package ' \
+                   'dependency from your app target manually in Xcode.'
+    end
+  end
+  begin
+    rnfirebase_fix_spm_archive_signature_collision(installer)
+  rescue StandardError => e
+    if defined?(Pod::UI)
+      Pod::UI.warn '[react-native-firebase] Couldn\'t add the Firebase/Google SPM binary ' \
+                   "xcframework signature workaround automatically (#{e.class}: #{e.message}). If your " \
+                   'Release archive fails with `"...xcframework-ios.signature" couldn\'t be copied to ' \
+                   '"Signatures" because an item with the same name already exists`, add a Run Script ' \
+                   'build phase to your app target that runs `rm -f ' \
+                   '"\\${CONFIGURATION_BUILD_DIR}"/<TheNameFromTheErrorMessage>.xcframework-ios.signature`.'
+    end
+  end
+  begin
+    rnfirebase_apply_spm_build_settings(installer)
+  rescue StandardError => e
+    if defined?(Pod::UI)
+      Pod::UI.warn "[react-native-firebase] Couldn't apply Firebase SPM build settings " \
+                   "automatically (#{e.class}: #{e.message}). " \
+                   'Add `rnfirebase_apply_spm_build_settings(installer)` ' \
+                   'to your Podfile\'s post_integrate block as a fallback if Release builds crash at launch with ' \
+                   'missing FIRComponent registrations, or Xcode reports that a Firebase module such as ' \
+                   '`FirebaseCoreInternal`/`FirebaseSharedSwift` cannot be resolved.'
+    end
+  end
+end
+
+# We wrap `Pod::Installer#generate_pods_project` (restore RNFB dynamic
+# frameworks after Expo's prebuilt downgrade and CocoaPods' transitive-static
+# validation, but before product/link-input generation),
+# `Pod::Installer#run_podfile_post_install_hooks` (Pods project: UUID counter,
+# RN SPM integrity, static-linkage guard) and, when present,
+# `Pod::Installer#run_podfile_post_integrate_hooks` (user project: embed
+# Firebase SPM frameworks + link FirebaseCore onto the app target).
+#
+# CocoaPods runs `post_install` *before* writing projects and *before*
+# `integrate_user_project`. That integrator is what adds
+# `[CP] Embed Pods Frameworks` on a clean app target and then *saves* the
+# user `.pbxproj`. Helpers that key off that phase (or that `project.save`
+# the app target) must therefore run in `post_integrate`, which CocoaPods
+# calls at the end of `integrate_user_project` after that save.
+#
+# Expo CNG `expo prebuild --clean` always starts from a template with no CP
+# embed phase. Running the user-project helpers from `post_install` silently
+# skipped every native target, then integrate wrote `[CP] Embed Pods
+# Frameworks` without `[RNFB] Embed Firebase SPM Frameworks` or a
+# FirebaseCore `PBXBuildFile` -- undefined `_OBJC_CLASS_$_FIRApp` from
+# AppDelegate (#9158 / CPRN-301). A committed bare-RN `ios/` folder that
+# already had the CP phase from a prior `pod install` could look fine at
+# `post_install` and hid this on #9164.
 #
 # This file is `require`d from each RNFB podspec, which CocoaPods evaluates
 # early, during dependency resolution (itself one of the first steps inside
 # `Installer#install!`). That's early enough for the patch installed here to
-# affect the *later*, fresh call to `run_podfile_post_install_hooks` made
-# further down in that same `install!` run.
+# affect the later hook calls in that same `install!` run.
 #
 # Why hook CocoaPods instead of React Native: `Pod::Installer` is a stable,
 # semantically-versioned public class that the wider CocoaPods plugin
@@ -547,23 +667,27 @@ end
 # changed in years. That makes it a meaningfully safer patch target than
 # RN's private, unversioned `react-native/scripts/cocoapods/spm.rb` helper,
 # which isn't part of any documented RN contract. If CocoaPods ever
-# renames/removes this method, the guards below no-op instead of raising,
-# and print a `pod install`-time warning (a visible integration error,
-# rather than a silent runtime dyld crash) telling you to call
+# renames/removes these methods, the guards below no-op instead of raising,
+# and print a `pod install`-time warning telling you to call
 # `rnfirebase_add_spm_embed_phase(installer)` from your own Podfile as a
-# fallback.
+# fallback. Older CocoaPods without `run_podfile_post_integrate_hooks` keeps
+# the user-project helpers on `post_install`.
 #
 # `installer_class` is only ever overridden by tests -- there's no real
 # `Pod::Installer` outside of a full CocoaPods environment.
 def rnfirebase_hook_cocoapods_post_install!(installer_class = (Pod::Installer if defined?(Pod::Installer)))
+  generate_method = :generate_pods_project
+  generate_original_method = :rnfirebase_original_generate_pods_project
   hook_method = :run_podfile_post_install_hooks
   original_method = :rnfirebase_original_run_podfile_post_install_hooks
+  integrate_hook_method = :run_podfile_post_integrate_hooks
+  integrate_original_method = :rnfirebase_original_run_podfile_post_integrate_hooks
 
   unless installer_class
     if defined?(Pod::UI)
       Pod::UI.warn '[react-native-firebase] `Pod::Installer` isn\'t defined -- automatic Firebase SPM setup ' \
                    '(dynamic framework embedding, etc.) was not hooked into `pod install`. Add ' \
-                   '`rnfirebase_add_spm_embed_phase(installer)` to your Podfile\'s post_install block as a fallback.'
+                   '`rnfirebase_add_spm_embed_phase(installer)` to your Podfile\'s post_integrate block as a fallback.'
     end
     return
   end
@@ -573,19 +697,84 @@ def rnfirebase_hook_cocoapods_post_install!(installer_class = (Pod::Installer if
     if defined?(Pod::UI)
       Pod::UI.warn "[react-native-firebase] `Pod::Installer##{hook_method}` doesn't exist (a CocoaPods " \
                    'release may have renamed or removed it) -- automatic Firebase SPM setup was not hooked into ' \
-                   '`pod install`. Add `rnfirebase_add_spm_embed_phase(installer)` to your Podfile\'s post_install ' \
+                   '`pod install`. Add `rnfirebase_add_spm_embed_phase(installer)` to your Podfile\'s post_integrate ' \
                    'block as a fallback.'
     end
     return
   end
 
+  already_hooked_post_install = installer_class.method_defined?(original_method) ||
+                                installer_class.private_method_defined?(original_method)
+  already_hooked_generate = installer_class.method_defined?(generate_original_method) ||
+                            installer_class.private_method_defined?(generate_original_method)
+  already_hooked_post_integrate = installer_class.method_defined?(integrate_original_method) ||
+                                  installer_class.private_method_defined?(integrate_original_method)
+
+  generate_was_private = installer_class.private_method_defined?(generate_method)
+  generate_available = generate_was_private || installer_class.method_defined?(generate_method)
+  integrate_was_private = installer_class.private_method_defined?(integrate_hook_method)
+  post_integrate_available = integrate_was_private || installer_class.method_defined?(integrate_hook_method)
+
+  generate_unavailable_warning = :@rnfirebase_generate_pods_project_unavailable_warning
+  if !already_hooked_generate &&
+     !generate_available &&
+     defined?(Expo::PrecompiledModules) &&
+     Expo::PrecompiledModules.respond_to?(:enabled?) &&
+     Expo::PrecompiledModules.enabled? &&
+     defined?(Pod::UI) &&
+     !installer_class.instance_variable_defined?(generate_unavailable_warning)
+    Pod::UI.warn '[react-native-firebase] `Pod::Installer#generate_pods_project` does not exist ' \
+                 '(a CocoaPods release may have renamed or removed it) -- Expo prebuilt RNFB ' \
+                 'dynamic-linkage restoration was not hooked into `pod install`. Use the CocoaPods ' \
+                 'version required by your Expo SDK and report this version combination if the app ' \
+                 'links duplicate Firebase symbols.'
+    installer_class.instance_variable_set(generate_unavailable_warning, true)
+  end
+
   # Already hooked -- e.g. a second RNFB podspec also `require`d this same
-  # file within one `pod install` process (this file is required by path,
-  # and a hoisted/symlinked dependency layout can resolve to the "same"
-  # file more than once). This is expected and idempotent, not a failure --
-  # every multi-podspec RNFB install hits this exact path -- so it's
-  # deliberately silent rather than warning on every normal install.
-  return if installer_class.method_defined?(original_method) || installer_class.private_method_defined?(original_method)
+  # file within one `pod install` process. Expected and idempotent.
+  return if (already_hooked_generate || !generate_available) &&
+            already_hooked_post_install &&
+            (already_hooked_post_integrate || !post_integrate_available)
+
+  unless already_hooked_generate || !generate_available
+    installer_class.class_eval do
+      alias_method generate_original_method, generate_method
+
+      define_method(generate_method) do
+        # Expo's patched pre-install implementation has already downgraded
+        # React-Core-dependent targets, and CocoaPods has already validated
+        # that graph. Restore RNFB immediately before CocoaPods reads each
+        # pod target's build type to generate products and app link inputs.
+        begin
+          rnfirebase_restore_dynamic_linkage_after_expo_prebuilt!(self)
+        rescue StandardError => e
+          if defined?(Pod::UI)
+            Pod::UI.warn '[react-native-firebase] Expo prebuilt RNFB dynamic-linkage restoration failed ' \
+                         "(#{e.class}: #{e.message}). Pod install aborted to avoid a partial restore."
+          end
+          raise
+        end
+        send(generate_original_method)
+      end
+    end
+    installer_class.send(:private, generate_method) if generate_was_private
+  end
+
+  unless already_hooked_post_integrate || !post_integrate_available
+    installer_class.class_eval do
+      alias_method integrate_original_method, integrate_hook_method
+
+      define_method(integrate_hook_method) do
+        result = send(integrate_original_method)
+        rnfirebase_run_spm_user_project_hooks(self)
+        result
+      end
+    end
+    installer_class.send(:private, integrate_hook_method) if integrate_was_private
+  end
+
+  return if already_hooked_post_install
 
   installer_class.class_eval do
     alias_method original_method, hook_method
@@ -599,7 +788,7 @@ def rnfirebase_hook_cocoapods_post_install!(installer_class = (Pod::Installer if
       rnfirebase_fail_if_spm_static_linkage!(self)
       # Soft ensure (warn on unexpected errors) -- paired with the hard
       # `rnfirebase_verify_pods_project_uuid_integrity!` after original
-      # post_install, same pattern as embed-phase add + verify below.
+      # post_install.
       begin
         rnfirebase_ensure_pods_uuid_counter_safe!(self)
       rescue StandardError => e
@@ -614,71 +803,10 @@ def rnfirebase_hook_cocoapods_post_install!(installer_class = (Pod::Installer if
       # Deliberately not rescued: if RN SPM overwrote `rootObject`, continuing
       # would only delay the failure to Xcode with a worse diagnostic.
       rnfirebase_verify_pods_project_uuid_integrity!(self)
-      begin
-        rnfirebase_add_spm_embed_phase(self)
-      rescue StandardError => e
-        if defined?(Pod::UI)
-          Pod::UI.warn "[react-native-firebase] Couldn't embed Firebase SPM frameworks " \
-                       "automatically (#{e.class}: #{e.message}). Add `rnfirebase_add_spm_embed_phase(installer)` " \
-                       'to your Podfile\'s post_install block as a fallback.'
-        end
-      end
-      # Deliberately outside the `rescue` above, and not itself wrapped in a
-      # rescue-and-warn like the softer checks in this method: dynamic
-      # framework embedding is load-bearing (without it, the app crashes at
-      # launch with a missing-library dyld error), so if the phase still
-      # isn't actually on a target that needs it after the call above --
-      # whether that call raised, silently no-opped, or only partially
-      # applied -- this must abort `pod install` with a clear message
-      # rather than let a broken install continue, the same way
-      # `rnfirebase_fail_if_spm_static_linkage!` above is deliberately not
-      # rescued either.
-      rnfirebase_verify_spm_embed_phase_applied!(self)
-      begin
-        rnfirebase_add_spm_core_to_app_target(self)
-      rescue StandardError => e
-        if defined?(Pod::UI)
-          Pod::UI.warn "[react-native-firebase] Couldn't link FirebaseCore into the app target " \
-                       "automatically (#{e.class}: #{e.message}). " \
-                       'Add `rnfirebase_add_spm_core_to_app_target(installer)` ' \
-                       'to your Podfile\'s post_install block as a fallback if your own native code calls ' \
-                       'FIRApp/FIROptions APIs directly.'
-        end
-      end
-      begin
-        rnfirebase_remove_spm_core_from_app_target(self)
-      rescue StandardError => e
-        if defined?(Pod::UI)
-          Pod::UI.warn "[react-native-firebase] Couldn't remove a stale FirebaseCore SPM link from the " \
-                       "app target automatically (#{e.class}: #{e.message}). If you previously used SPM and have " \
-                       'since set `$RNFirebaseDisableSPM = true`, remove the "firebase-ios-sdk" Swift Package ' \
-                       'dependency from your app target manually in Xcode.'
-        end
-      end
-      begin
-        rnfirebase_fix_spm_archive_signature_collision(self)
-      rescue StandardError => e
-        if defined?(Pod::UI)
-          Pod::UI.warn '[react-native-firebase] Couldn\'t add the Firebase/Google SPM binary ' \
-                       "xcframework signature workaround automatically (#{e.class}: #{e.message}). If your " \
-                       'Release archive fails with `"...xcframework-ios.signature" couldn\'t be copied to ' \
-                       '"Signatures" because an item with the same name already exists`, add a Run Script ' \
-                       'build phase to your app target that runs `rm -f ' \
-                       '"\\${CONFIGURATION_BUILD_DIR}"/<TheNameFromTheErrorMessage>.xcframework-ios.signature`.'
-        end
-      end
-      begin
-        rnfirebase_apply_spm_build_settings(self)
-      rescue StandardError => e
-        if defined?(Pod::UI)
-          Pod::UI.warn "[react-native-firebase] Couldn't apply Firebase SPM build settings " \
-                       "automatically (#{e.class}: #{e.message}). " \
-                       'Add `rnfirebase_apply_spm_build_settings(installer)` ' \
-                       'to your Podfile\'s post_install block as a fallback if Release builds crash at launch with ' \
-                       'missing FIRComponent registrations, or Xcode reports that a Firebase module such as ' \
-                       '`FirebaseCoreInternal`/`FirebaseSharedSwift` cannot be resolved.'
-        end
-      end
+      # Current CocoaPods: user-project mutations run from post_integrate
+      # (after `[CP] Embed Pods Frameworks` exists). Older CocoaPods without
+      # that hook keeps them here.
+      rnfirebase_run_spm_user_project_hooks(self) unless post_integrate_available
       result
     end
   end
@@ -687,14 +815,15 @@ rescue StandardError => e
   if defined?(Pod::UI)
     Pod::UI.warn "[react-native-firebase] Couldn't hook CocoaPods to auto-embed Firebase SPM " \
                  "frameworks (#{e.class}: #{e.message}). Add `rnfirebase_add_spm_embed_phase(installer)` " \
-                 'to your Podfile\'s post_install block as a fallback.'
+                 'to your Podfile\'s post_integrate block as a fallback.'
   end
 end
 
 # Adds a direct SPM product dependency on `FirebaseCore` to the *app's own*
 # native target(s) -- not just RNFB's pod targets. Runs automatically on every
-# `pod install`/`pod update` alongside `rnfirebase_add_spm_embed_phase` -- see
-# `rnfirebase_hook_cocoapods_post_install!` below -- so you normally never
+# `pod install`/`pod update` from `rnfirebase_run_spm_user_project_hooks`
+# (post_integrate on current CocoaPods; post_install fallback otherwise) --
+# see `rnfirebase_hook_cocoapods_post_install!` -- so you normally never
 # need to call this yourself.
 #
 # Why this needs to exist: every react-native-firebase app is required to
@@ -1044,13 +1173,29 @@ def rnfirebase_apply_spm_build_settings(installer)
     project.save if project_modified
   end
 
-  installer.pods_project.targets.each do |target|
+  # User-project settings are `project.save`d above. Pods settings used to
+  # live only on the in-memory `installer.pods_project` during `post_install`,
+  # when CocoaPods still writes that file. The user-project hooks now run
+  # from `post_integrate` (after that write), so these mutations are lost
+  # unless we save. Xcode 26 then keeps explicit modules on RNFB pod
+  # targets and fails Swift compiles that import Firebase SPM internals
+  # (`FirebaseCoreInternal`, `FirebaseSharedSwift`) with "compilation
+  # search paths unable to resolve module dependency".
+  pods_project = installer.pods_project
+  return unless pods_project
+
+  pods_modified = false
+  pods_project.targets.each do |target|
     target.build_configurations.each do |config|
       explicit_modules_settings.each do |setting|
-        config.build_settings[setting] = 'NO'
+        unless config.build_settings[setting] == 'NO'
+          config.build_settings[setting] = 'NO'
+          pods_modified = true
+        end
       end
     end
   end
+  pods_project.save if pods_modified
 end
 
 rnfirebase_hook_cocoapods_post_install!

package/ios/RNFBApp/RNFBAppModule.mm

@@ -41,8 +41,13 @@
 #endif
 
 @interface RNFBAppModule () <NativeRNFBTurboAppSpec, RCTInvalidating>
+
++ (void)setCustomDomain:(nullable NSString *)authDomain forAppName:(NSString *)appName;
+
 @end
 
+static NSMutableDictionary<NSString *, NSString *> *customAuthDomains;
+
 @implementation RNFBAppModule
 
 #pragma mark -
@@ -102,11 +107,11 @@ RCT_EXPORT_MODULE(NativeRNFBTurboApp)
   return constants;
 }
 
-- (facebook::react::ModuleConstants<JS::NativeRNFBTurboApp::Constants::Builder>)constantsToExport {
+- (facebook::react::ModuleConstants<JS::NativeRNFBTurboApp::Constants>)constantsToExport {
   return [_RCTTypedModuleConstants newWithUnsafeDictionary:[self appConstantsDictionary]];
 }
 
-- (facebook::react::ModuleConstants<JS::NativeRNFBTurboApp::Constants::Builder>)getConstants {
+- (facebook::react::ModuleConstants<JS::NativeRNFBTurboApp::Constants>)getConstants {
   return [self constantsToExport];
 }
 
@@ -200,6 +205,9 @@ RCT_EXPORT_MODULE(NativeRNFBTurboApp)
   RCTUnsafeExecuteOnMainQueueSync(^{
     FIRApp *firApp;
     NSString *appName = [appConfig valueForKey:@"name"];
+    NSString *authDomain = [options valueForKey:@"authDomain"];
+    NSString *jsAppName = (appName.length > 0) ? appName : DEFAULT_APP_DISPLAY_NAME;
+    BOOL isDefaultApp = !appName || [appName isEqualToString:DEFAULT_APP_DISPLAY_NAME];
 
     NSString *appId = [options valueForKey:@"appId"];
     NSString *messagingSenderId = [options valueForKey:@"messagingSenderId"];
@@ -223,17 +231,16 @@ RCT_EXPORT_MODULE(NativeRNFBTurboApp)
       firOptions.appGroupID = [options valueForKey:@"appGroupId"];
     }
 
-    if ([options valueForKey:@"authDomain"] != nil) {
-      DLog(@"RNFBAuth app: %@ customAuthDomain: %@", appName, [options valueForKey:@"authDomain"]);
-      if (customAuthDomains == nil) {
-        customAuthDomains = [[NSMutableDictionary alloc] init];
-      }
-      customAuthDomains[appName] = [options valueForKey:@"authDomain"];
-    }
     @try {
-      if (!appName || [appName isEqualToString:DEFAULT_APP_DISPLAY_NAME]) {
-        [FIRApp configureWithOptions:firOptions];
-        firApp = [FIRApp defaultApp];
+      if (isDefaultApp) {
+        // Native bootstrap often already called [FIRApp configure]. Still accept a JS/bridge
+        // initializeApp for the default app so customAuthDomains can be keyed by [DEFAULT].
+        if ([FIRApp defaultApp] != nil) {
+          firApp = [FIRApp defaultApp];
+        } else {
+          [FIRApp configureWithOptions:firOptions];
+          firApp = [FIRApp defaultApp];
+        }
       } else {
         [FIRApp configureWithName:appName options:firOptions];
         firApp = [FIRApp appNamed:appName];
@@ -242,6 +249,9 @@ RCT_EXPORT_MODULE(NativeRNFBTurboApp)
       return [RNFBSharedUtils rejectPromiseWithExceptionDict:reject exception:exception];
     }
 
+    // Store under the JS bridge app name ([DEFAULT]), never native __FIRAPP_DEFAULT.
+    [RNFBAppModule setCustomDomain:authDomain forAppName:jsAppName];
+
     firApp.dataCollectionDefaultEnabled =
         (BOOL)[appConfig valueForKey:@"automaticDataCollectionEnabled"];
 
@@ -249,11 +259,25 @@ RCT_EXPORT_MODULE(NativeRNFBTurboApp)
   });
 }
 
-static NSMutableDictionary<NSString *, NSString *> *customAuthDomains;
-
 + (NSString *)getCustomDomain:(NSString *)appName {
-  DLog(@"authDomains: %@", customAuthDomains);
-  return customAuthDomains[appName];
+  @synchronized(self) {
+    DLog(@"authDomains: %@", customAuthDomains);
+    return customAuthDomains[appName];
+  }
+}
+
++ (void)setCustomDomain:(nullable NSString *)authDomain forAppName:(NSString *)appName {
+  @synchronized(self) {
+    if (authDomain != nil) {
+      DLog(@"RNFBAuth app: %@ customAuthDomain: %@", appName, authDomain);
+      if (customAuthDomains == nil) {
+        customAuthDomains = [[NSMutableDictionary alloc] init];
+      }
+      customAuthDomains[appName] = authDomain;
+    } else {
+      [customAuthDomains removeObjectForKey:appName];
+    }
+  }
 }
 
 - (void)setLogLevel:(NSString *)logLevel {
@@ -288,10 +312,12 @@ static NSMutableDictionary<NSString *, NSString *> *customAuthDomains;
 
   [firApp deleteApp:^(BOOL success) {
     if (success) {
+      [RNFBAppModule setCustomDomain:nil forAppName:appName];
       resolve([NSNull null]);
     } else {
       [firApp deleteApp:^(BOOL success2) {
         if (success2) {
+          [RNFBAppModule setCustomDomain:nil forAppName:appName];
           resolve([NSNull null]);
         } else {
           reject(@"app/delete-app-failed", @"Failed to delete the specified app.", nil);

package/ios/RNFBApp/RNFBHandleMap.h

@@ -0,0 +1,73 @@
+/**
+ * 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
+
+FOUNDATION_EXPORT NSErrorDomain const RNFBHandleMapErrorDomain;
+
+typedef NS_ERROR_ENUM(RNFBHandleMapErrorDomain, RNFBHandleMapErrorCode){
+    RNFBHandleMapErrorCollision = 1,
+};
+
+/**
+ * Thread-safe id → handle registry. The lock only moves pointers; this class never invokes methods
+ * on stored values (no SDK cancel/remove). Callers `take` or `takeAll`, then act on the returned
+ * object(s) outside the lock. Keys are typically NSNumber or NSString.
+ *
+ * `put` is unique: an occupied id fails with `RNFBHandleMapErrorCollision`. There is no upsert.
+ * Use `putIfAbsent` (first wins), `putIfAbsentOrSame` (first wins or same instance), or
+ * `putReplacing` (last wins) for atomic upsert.
+ *
+ * Do not lock on a `RNFBHandleMap` instance. This type uses a private lock object; callers that
+ * synchronize on the map can deadlock. Never `@synchronized(handleMap)` around these methods.
+ */
+@interface RNFBHandleMap : NSObject
+
+/// Registers `value` under `key`. Returns NO and sets `error` if `key` is already occupied.
+- (BOOL)put:(id)key value:(id)value error:(NSError *_Nullable *_Nullable)error;
+
+/// Stores `value` under `key` only when the key is free (first wins). Returns NO if occupied.
+- (BOOL)putIfAbsent:(id)key value:(id)value;
+
+/// Under one lock: stores when free, or YES when existing is the same instance (`==`). NO if
+/// occupied by a different value.
+- (BOOL)putIfAbsentOrSame:(id)key value:(id)value;
+
+/// Atomically replaces the mapping for `key` (last wins). Returns the previous value, or nil.
+- (nullable id)putReplacing:(id)key value:(id)value;
+
+/// Peeks at the handle for `key` without removing it (for emit while still registered).
+- (nullable id)get:(id)key;
+
+/// Removes and returns the handle for `key`, or nil if absent.
+- (nullable id)take:(id)key;
+
+/// When `key` is mapped and `condition` returns YES for the handle, removes and returns it;
+/// otherwise returns nil and leaves the map unchanged. Lookup, condition, and removal run under one
+/// lock — use for check-and-take that must not race with concurrent `put` / `take` on the same key.
+/// Keep `condition` lightweight (no SDK cancel/remove).
+- (nullable id)takeIf:(id)key when:(BOOL (^)(id value))condition;
+
+/// Snapshot of current values, then clear. Cancel/remove each returned object after this method
+/// returns, not under this map's lock.
+- (NSArray *)takeAll;
+
+@end
+
+NS_ASSUME_NONNULL_END