react-native-acoustic-connect-beta 18.0.27 → 18.0.29

package/AcousticConnectRN.podspec

@@ -10,10 +10,10 @@ dependencyName = useRelease ? 'AcousticConnect' : 'AcousticConnectDebug'
 iOSVersion = connectConfig["Connect"]["iOSVersion"]
 
 # Floor required by the RN bridge:
-#   - `ConnectSDK.shared.enable(with:)` and `ConnectConfig` landed in 2.0.0
-#     (CA-135041) — anything older lacks the Swift symbols this file imports.
+#   - `ConnectSDK.shared.enable(with:)` and `ConnectConfig` landed in 2.0.0;
+#     anything older lacks the Swift symbols this file imports.
 #   - Bundle-less init via `_connectApplyBundleDefaults` landed in 2.0.5
-#     (CA-136977, Release_Connect_Module_2_0_5, 2026-04-13). Without it,
+#     (Release_Connect_Module_2_0_5, 2026-04-13). Without it,
 #     consumers who don't bundle `EOCoreSettings.bundle` + `TLFResources.bundle`
 #     fail to enable the SDK at all — the bridge ships no bundles and relies
 #     on programmatic config, so this fix is load-bearing here.
@@ -29,7 +29,7 @@ iOSVersion = connectConfig["Connect"]["iOSVersion"]
 # `ConnectConfig.json -> Connect.PushEnabled` (mirrors the Android conditional
 # on `connect-push-fcm` in `android/build.gradle`).
 # 2.1.12 floor: `ConnectSDK.shared.push.requestAuthorization()` and
-# `getCurrentAuthorization()` (CA-144303) land in 2.1.12. The push permission
+# `getCurrentAuthorization()` land in 2.1.12. The push permission
 # bridge methods call them directly, so an older pod would fail to compile.
 sdkFloor = '>= 2.1.12'
 dependencyRequirements = iOSVersion.to_s.empty? ? [sdkFloor] : [sdkFloor, iOSVersion]

package/README.md

@@ -11,11 +11,34 @@ For the full product overview see the
 
 - React Native 0.82.x – 0.85.x with the new architecture
 - React 19.1.1 or newer (or whatever your RN version pins)
+- `react-native-nitro-modules` at the **exact** version this package pins in `peerDependencies` (currently **`0.35.9`**) — your app must resolve exactly this version; see [Nitro version pin](#nitro-version-pin)
 - Node 20 or newer
 - iOS deployment target ≥ 15.1, AcousticConnect / AcousticConnectDebug pod ≥ 2.0.5
 - Android `minSdk` ≥ 26, `compileSdk` ≥ 35, `io.github.go-acoustic:connect` in `[11.0.11, 12.0.0)`
 - **Expo is not supported by this package.** Expo apps should use the sibling
-  Config Plugin (tracked separately under PES-4002 / CA-137701).
+  Config Plugin (shipped separately).
+
+### Nitro version pin
+
+This package pins `react-native-nitro-modules` to an **exact version**
+(currently **`0.35.9`**) in its `peerDependencies` — deliberately *not* a range.
+**Your app must resolve exactly that version.**
+
+**Why (important): Nitro patch releases can contain breaking changes.** The SDK
+ships native bindings generated against one specific Nitro version, and Nitro's
+generated-code ↔ runtime contract is **not patch-safe**. For example, a
+`0.35.4` → `0.35.9` *patch* bump changed Nitro's native registration and caused
+this SDK's HybridObject to fail to load with a `ClassNotFoundException`, taking
+the entire module offline at runtime. Because even a patch can break it, a
+version *range* (`^`/`~`/`>=…<…`) cannot guarantee compatibility — so the pin is
+exact.
+
+If your app resolves a different Nitro version, the SDK may fail to start. You
+*can* force past the peer check with `--legacy-peer-deps` / `--force`, **but
+then you own making it work** — we cannot guard against breaking changes in
+arbitrary future Nitro patch releases. When this SDK adopts a newer Nitro, it
+ships in a new SDK release with the pin bumped; upgrade the SDK and Nitro
+together.
 
 ## Installation
 
@@ -222,16 +245,22 @@ and the `<Connect>` component.
 
 ### `npm install` peer-dependency conflicts
 
-If `npm install` errors out on a peer-dependency resolution involving Expo or
-older `react-native-nitro-modules` versions, retry with:
+This package pins `react-native-nitro-modules` to an **exact** version (see
+[Nitro version pin](#nitro-version-pin)). If `npm install` errors on the Nitro
+peer, your app is resolving a *different* Nitro version. Check it with:
 
 ```bash
-npm install react-native-nitro-modules --legacy-peer-deps
+npm ls react-native-nitro-modules
 ```
 
-This usually only happens when an existing project pulls in stale Expo
-transitives. Permanent fix: align RN, React, and Nitro versions with the
-[Requirements](#requirements) section above.
+**Supported fix:** align your app to the exact version this package requires
+(and match React Native / React per the [Requirements](#requirements)).
+
+`--legacy-peer-deps` / `--force` will silence the error, but the pin is
+intentional: a mismatched Nitro version can break the SDK at runtime (an
+init-time `ClassNotFoundException`), and bypassing means **you take on that
+risk** — we cannot guard against breaking changes in arbitrary Nitro patch
+releases. Match the version rather than bypass it.
 
 ### iOS — `pod install` fails with `[Connect] requires AcousticConnect >= 2.0.5`
 

package/android/CMakeLists.txt

@@ -7,7 +7,7 @@
 # prohibited.
 #
 #
-# Created by Omar Hernandez on 5/9/25.
+# Created on 5/9/25.
 #
 
 project(AcousticConnectRN)

package/android/build.gradle

@@ -7,7 +7,7 @@
 // prohibited.
 //
 //
-//  Created by Omar Hernandez on 5/9/25.
+//  Created on 5/9/25.
 //
 
 buildscript {

package/android/src/main/assets/ConnectBasicConfig.properties

@@ -1,4 +1,4 @@
-#Mon Jun 01 09:10:13 PDT 2026
+#Fri Jun 05 02:59:23 PDT 2026
 UseWhiteList=true
 PrintScreen=3
 UseRandomSample=false

package/android/src/main/java/com/acousticconnectrn/AcousticConnectRNPackage.java

@@ -7,7 +7,7 @@
 // prohibited.
 //
 //
-//  Created by Omar Hernandez on 5/9/25.
+//  Created on 5/9/25.
 //
 
 package com.acousticconnectrn;

package/android/src/main/java/com/acousticconnectrn/HybridAcousticConnectRN.kt

@@ -7,7 +7,7 @@
 // prohibited.
 //
 //
-//  Created by Omar Hernandez on 5/9/25.
+//  Created on 5/9/25.
 //
 
 package com.acousticconnectrn
@@ -29,6 +29,7 @@ import android.view.WindowManager
 import android.view.inputmethod.InputMethodManager
 import android.widget.EditText
 import android.widget.TextView
+import androidx.activity.ComponentActivity
 import androidx.fragment.app.DialogFragment
 import com.acoustic.connect.android.connectmod.Connect
 import com.acoustic.connect.android.connectmod.Connect.TLF_ON_FOCUS_CHANGE_IN
@@ -47,6 +48,7 @@ import com.acoustic.connect.android.connectmod.Connect.logScreenview
 import com.acoustic.connect.android.connectmod.Connect.onResume
 import com.acoustic.connect.android.connectmod.Connect.registerFormField
 import com.acoustic.connect.android.connectmod.Connect.resumeConnect
+import com.acoustic.connect.android.connectmod.push.PushPermissionState
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.UIManagerHelper
@@ -60,6 +62,7 @@ import com.margelo.nitro.acousticconnectrn.Variant_Boolean_String_Double
 import com.margelo.nitro.acousticconnectrn.Variant_NullType_Boolean
 import com.margelo.nitro.acousticconnectrn.Variant_NullType_String
 import com.margelo.nitro.core.ArrayBuffer
+import com.margelo.nitro.core.NullType
 import com.margelo.nitro.core.Promise
 import com.tl.uic.Tealeaf
 import com.tl.uic.model.ScreenviewType
@@ -173,7 +176,7 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
         return app
     }
 
-    // region Gate-keeper API (CA-137696)
+    // region Gate-keeper API
 
     /**
      * Re-enables the Connect SDK after a prior `disable()`. All configuration
@@ -190,8 +193,7 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
      * Push wiring on Android is gated at build time by `Connect.PushEnabled`
      * in `ConnectConfig.json`, which `android/build.gradle` consults to
      * include the `connect-push-fcm` artifact. Token forwarding to Connect
-     * lives in CA-137698 and runs through the host app's
-     * `FirebaseMessagingService`.
+     * runs through the host app's `FirebaseMessagingService`.
      *
      * @return true on accepted dispatch, false if no application context.
      */
@@ -231,76 +233,227 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
         return true
     }
 
-    // MARK: - Push (Android) — STUBS
+    // region Push (Android)
     //
-    // The shared Nitro spec (added by the iOS push story, CA-137697) declares
-    // these as abstract members on BOTH platforms, so the Android library must
-    // implement them to compile. These are intentional NO-OP placeholders to
-    // keep the shared spec landable; the real Android behaviour lands with:
-    //   - CA-144821: pushGetToken / pushGetTokenAsync (separate session)
-    //   - CA-144822: pushDidReceiveNotification manual-mode dispatch
-    //   - CA-144823: permission methods (request / get / authorization)
-    // until then they return inert defaults and never throw.
+    // The shared Nitro spec declares these push methods on both platforms. On
+    // Android the native SDK owns the ENTIRE push lifecycle — Connect's own
+    // FirebaseMessagingService (shipped in connect-push-fcm) handles inbound
+    // delivery, PushReceived / PushAction logging, and token registration
+    // automatically. Unlike iOS, Android has no manual JS-forwarding API, so
+    // every JS→native forwarder is a no-op that reports "handled", kept only
+    // for cross-platform API symmetry:
+    //   - pushDidReceiveNotification, pushDidReceiveResponse,
+    //     pushDidRegisterWithToken, pushDidFailToRegister,
+    //     pushDidReceiveAuthorization
+    //
+    // The only Android-relevant behaviour is permission wiring:
+    //   - pushRequestPermission / pushGetPermissionState — POST_NOTIFICATIONS
+    //
+    // pushGetToken / pushGetTokenAsync are intentionally NOT on the surface —
+    // parked (the native SDK registers the token with Connect automatically;
+    // no JS accessor is needed). None of these methods reject.
 
+    /**
+     * iOS-primary forwarder. On Android the FCM token is captured and registered
+     * with Connect automatically by the native messaging service, so this is a
+     * no-op that reports "handled". Never rejects.
+     */
     override fun pushDidRegisterWithToken(deviceToken: ArrayBuffer): Promise<Boolean> {
-        Log.w(TAG, "[bridge] pushDidRegisterWithToken: Android stub (CA-144822/823 pending)")
-        return Promise.resolved(false)
+        Log.d(TAG, "[bridge] pushDidRegisterWithToken: no-op on Android (native SDK owns token registration)")
+        return Promise.resolved(true)
     }
 
+    /**
+     * iOS-primary forwarder. Android surfaces registration failures through the
+     * native SDK's own error path, so this is a no-op. Never rejects.
+     */
     override fun pushDidFailToRegister(error: PushErrorInfo): Promise<Boolean> {
-        Log.w(TAG, "[bridge] pushDidFailToRegister: Android stub (CA-144822/823 pending)")
-        return Promise.resolved(false)
+        Log.d(TAG, "[bridge] pushDidFailToRegister: no-op on Android (domain=${error.domain}, code=${error.code})")
+        return Promise.resolved(true)
     }
 
+    /**
+     * iOS-primary forwarder. Android has **no** manual push-delivery API: the
+     * native SDK's own `FirebaseMessagingService` (shipped in `connect-push-fcm`)
+     * receives inbound messages and logs the PushReceived signal automatically.
+     * There is no sanctioned JS-forwarding entry point on Android — and outside
+     * Connect's push transport there is no registered device to attribute a
+     * PushReceived to — so this is a no-op that reports "handled". Kept for
+     * cross-platform API symmetry with iOS (where it forwards to the SDK in
+     * manual mode). Never rejects.
+     */
     override fun pushDidReceiveNotification(userInfo: Map<String, Variant_Boolean_String_Double>): Promise<Boolean> {
-        Log.w(TAG, "[bridge] pushDidReceiveNotification: Android stub (CA-144822 pending)")
-        return Promise.resolved(false)
+        Log.d(TAG, "[bridge] pushDidReceiveNotification: no-op on Android (native FCM service owns delivery + logging)")
+        return Promise.resolved(true)
     }
 
+    /**
+     * iOS-primary forwarder. Tap (PushAction) handling on Android routes through
+     * the native SDK's `NotificationActionActivity`, so this is a no-op. Never
+     * rejects.
+     */
     override fun pushDidReceiveResponse(
         actionIdentifier: String,
-        userInfo: Map<String, Variant_Boolean_String_Double>
+        userInfo: Map<String, Variant_Boolean_String_Double>,
     ): Promise<Boolean> {
-        Log.w(TAG, "[bridge] pushDidReceiveResponse: Android stub (CA-144822 pending)")
-        return Promise.resolved(false)
+        Log.d(TAG, "[bridge] pushDidReceiveResponse: no-op on Android (native SDK handles tap actions)")
+        return Promise.resolved(true)
     }
 
+    /**
+     * No-op on Android. Permission state is auto-detected on every activity
+     * start by the SDK's ActivityLifecycleHandler, so an externally-supplied
+     * authorization result needs no forwarding. Kept for API symmetry with iOS
+     * (where it forwards to the native SDK). Never rejects.
+     */
     override fun pushDidReceiveAuthorization(granted: Variant_NullType_Boolean?, error: PushErrorInfo?): Promise<Boolean> {
-        Log.w(TAG, "[bridge] pushDidReceiveAuthorization: Android stub (CA-144823 pending)")
-        return Promise.resolved(false)
+        Log.d(TAG, "[bridge] pushDidReceiveAuthorization: no-op on Android (state self-heals via lifecycle)")
+        return Promise.resolved(true)
     }
 
+    /**
+     * Requests the POST_NOTIFICATIONS permission. Delegates to
+     * [com.acoustic.connect.android.connectmod.push.PushApi.requestNotificationPermission],
+     * which fully manages the system dialog and the Activity Result registration,
+     * then resolves from its one-shot callback. On pre-TIRAMISU devices the SDK
+     * resolves `granted = true` immediately.
+     *
+     * **Never rejects.** If no foreground [ComponentActivity] is available, or
+     * the SDK call throws, it resolves `{ granted: false, error: <reason> }`.
+     *
+     * Intentionally NOT gated by [isConnectPushFcmAvailable]. The permission
+     * API ([PushApi]/`ConnectPush` and the `NotificationPermission*` classes)
+     * ships in the core `connect` artifact, which is always on the classpath —
+     * the `connect-push-fcm` variant pulls `connect` in transitively (see
+     * `android/build.gradle`). So `Connect.push` is a non-null core object, not
+     * a stub, and accessing it cannot raise `NoClassDefFoundError` from a
+     * missing FCM artifact. POST_NOTIFICATIONS is an OS-level concern that is
+     * meaningful regardless of whether FCM message delivery is bundled; gating
+     * it on the FCM probe would wrongly disable a working capability in
+     * analytics-only (`PushEnabled=false`) builds. The only FCM-adjacent path
+     * the SDK runs from here — `sendToken()` in the result callback — is itself
+     * guarded by the SDK's `isInitialized()` and no-ops when transport is absent.
+     */
     override fun pushRequestPermission(): Promise<PushPermissionResult> {
-        Log.w(TAG, "[bridge] pushRequestPermission: Android stub (CA-144823 pending)")
-        return Promise.resolved(PushPermissionResult(granted = false, error = null))
+        val promise = Promise<PushPermissionResult>()
+        runOnMain {
+            // Re-read the foreground activity inside the main-looper block: it can
+            // change between the bridge call and this dispatch (e.g. a rotation /
+            // configuration change). Guard against a finishing or destroyed
+            // activity, not just null — handing such an activity to the SDK lets it
+            // register an ActivityResultLauncher whose result callback never fires,
+            // which would hang this Promise forever. Resolving deterministically
+            // here is preferable to a silent never-resolving Promise.
+            val activity = getCurrentActivity() as? ComponentActivity
+            if (activity == null || activity.isFinishing || activity.isDestroyed) {
+                Log.w(TAG, "[bridge] pushRequestPermission: no usable foreground ComponentActivity")
+                promise.resolve(
+                    PushPermissionResult(false, Variant_NullType_String.create("no-foreground-activity")),
+                )
+                return@runOnMain
+            }
+            try {
+                // The `granted` callback is always delivered on the main thread:
+                // either synchronously here (pre-TIRAMISU / already-granted paths,
+                // still on this looper) or via AndroidX ActivityResultRegistry,
+                // which dispatches results on the main thread. Promise.resolve is
+                // additionally thread-agnostic — it delegates to native, which
+                // marshals onto the JS thread — so resolution is safe regardless of
+                // the calling thread.
+                Connect.push.requestNotificationPermission(activity) { granted ->
+                    promise.resolve(PushPermissionResult(granted, null))
+                }
+            } catch (e: Exception) {
+                Log.w(TAG, "[bridge] pushRequestPermission: request failed — ${e.message}")
+                promise.resolve(
+                    PushPermissionResult(false, Variant_NullType_String.create(e.message ?: "permission-request-failed")),
+                )
+            }
+        }
+        return promise
     }
 
+    /**
+     * Returns the current POST_NOTIFICATIONS permission as the cross-platform
+     * tri-state: `true` granted, `false` denied, `null` not yet
+     * determined. Maps [PushPermissionState] from the native SDK. Does not
+     * prompt. Never rejects — resolves `null` if the context is unavailable or
+     * the SDK call throws.
+     *
+     * Runs on the main looper (via [runOnMain]), matching every other
+     * `Connect.push.*` invocation in this bridge rather than executing on the
+     * Nitro bridge thread the HybridObject method is dispatched on. Besides
+     * keeping the threading contract consistent, this serialises the call with
+     * [pushRequestPermission]'s SDK callback: both ultimately touch the same
+     * notification-permission `SharedPreferences` store (the SDK's
+     * `getPushPermissionState` does a read-then-write to reconcile a
+     * Settings-side revocation), so funnelling both through main avoids an
+     * interleaved read/write across threads.
+     *
+     * Like [pushRequestPermission], this is intentionally NOT gated by
+     * [isConnectPushFcmAvailable] — the permission API lives in the core
+     * `connect` artifact (always on the classpath) and never touches the FCM
+     * transport classes, so there is no missing-artifact / stub-object risk.
+     */
     override fun pushGetPermissionState(): Promise<Variant_NullType_Boolean> {
-        Log.w(TAG, "[bridge] pushGetPermissionState: Android stub (CA-144823 pending)")
-        return Promise.resolved(Variant_NullType_Boolean.create(false))
+        val promise = Promise<Variant_NullType_Boolean>()
+        runOnMain {
+            val context = applicationContext?.applicationContext
+            if (context == null) {
+                promise.resolve(Variant_NullType_Boolean.create(NullType.NULL))
+                return@runOnMain
+            }
+            try {
+                // Redundant against today's 3-value enum, but kept deliberately
+                // for forward-compatibility with future SDK enum values (see the
+                // `else` branch below), so silence the redundancy warning.
+                @Suppress("REDUNDANT_ELSE_IN_WHEN")
+                val triState = when (Connect.push.getPushPermissionState(context)) {
+                    PushPermissionState.GRANTED -> Variant_NullType_Boolean.create(true)
+                    PushPermissionState.DENIED -> Variant_NullType_Boolean.create(false)
+                    PushPermissionState.NOT_DETERMINED -> Variant_NullType_Boolean.create(NullType.NULL)
+                    // PushPermissionState is a Connect-SDK enum that may gain
+                    // values in a future release. An explicit `else` keeps this
+                    // forward-compatible: it avoids a compile break if the bridge
+                    // is rebuilt against an SDK with a new state, and replaces the
+                    // synthetic NoWhenBranchMatchedException (binary-incompat case:
+                    // bridge built against the old enum, run against a newer one)
+                    // with a deliberate fallback. Any unknown/new state maps to the
+                    // tri-state `null` ("not determined") — the safest default.
+                    else -> Variant_NullType_Boolean.create(NullType.NULL)
+                }
+                promise.resolve(triState)
+            } catch (e: Exception) {
+                Log.w(TAG, "[bridge] pushGetPermissionState: query failed — ${e.message}")
+                promise.resolve(Variant_NullType_Boolean.create(NullType.NULL))
+            }
+        }
+        return promise
     }
 
+    // endregion
+
     /**
      * Checks whether the `connect-push-fcm` artifact is on the classpath and
      * logs the result. The artifact is gated by `Connect.PushEnabled` in
      * `ConnectConfig.json` via `android/build.gradle`'s conditional
      * `implementation` clause. A missing artifact when `PushEnabled` was set
      * to true points at a build-pipeline issue (didn't run `config.gradle`
-     * or the conditional didn't fire). Once CA-137698 lands the actual
-     * Connect push API on Android, this method also gates the wire-up.
+     * or the conditional didn't fire). This method also gates the push
+     * wire-up against the resolved Connect push API on Android.
      */
     private fun logResolvedPushAvailability() {
         val pushAvailable = isConnectPushFcmAvailable()
         Log.i(TAG, "[config] connect-push-fcm on classpath: $pushAvailable")
         if (!pushAvailable) {
-            Log.i(TAG, "[config] Push is not active on Android in this build. To enable, set Connect.PushEnabled=true in ConnectConfig.json and re-sync Gradle to include connect-push-fcm. Token forwarding wires in CA-137698.")
+            Log.i(TAG, "[config] Push is not active on Android in this build. To enable, set Connect.PushEnabled=true in ConnectConfig.json and re-sync Gradle to include connect-push-fcm.")
         }
     }
 
     private fun isConnectPushFcmAvailable(): Boolean {
         // Probe a known class shipped by the connect-push-fcm artifact. The
-        // exact class lives in the Connect Android SDK's push module and is
-        // finalised under CA-137698; this Class.forName probe is robust to
+        // exact class lives in the Connect Android SDK's push module. This
+        // Class.forName probe is robust to
         // package-name changes because it falls through silently when the
         // class is missing (which is the default in a no-push build).
         return try {
@@ -466,6 +619,52 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
         return result
     }
 
+    /**
+     * Logs a user identity so device activity can be associated with a known
+     * Connect contact. Wraps [Connect.logIdentificationEvent].
+     *
+     * Returns a [Promise] to match the cross-platform spec — the iOS identity
+     * API is main-actor isolated and async. The native call is synchronous and
+     * returns false (emitting no signal) when either identifier is blank, so no
+     * extra guard is needed here.
+     *
+     * A `"url"` entry in [additionalParameters] is routed to the SDK's explicit
+     * `url` parameter so the JS surface matches iOS, where `url` rides inside the
+     * parameter map. When absent, the SDK's own default URL applies.
+     *
+     * @param identifierName Identifier name, e.g. "Email".
+     * @param identifierValue Identifier value, e.g. "user@example.com".
+     * @param signalType Optional signal type; defaults to "loggedIn" when omitted.
+     * @param additionalParameters Optional extra key/value pairs merged into the
+     *   signal. Defaults to `{ "registrationMethod": "email" }` only when null
+     *   (omitted); an explicit map — including an empty one — is used as-is.
+     * @return A promise resolving to true if the signal was queued, false otherwise.
+     */
+    override fun logIdentity(
+        identifierName: String,
+        identifierValue: String,
+        signalType: String?,
+        additionalParameters: Map<String, String>?
+    ): Promise<Boolean> {
+        val params = additionalParameters ?: mapOf("registrationMethod" to "email")
+        val resolvedSignalType = signalType ?: "loggedIn"
+        val result = params["url"]?.let { url ->
+            Connect.logIdentificationEvent(
+                identifierName,
+                identifierValue,
+                url,
+                resolvedSignalType,
+                params - "url"
+            )
+        } ?: Connect.logIdentificationEvent(
+            identifierName = identifierName,
+            identifierValue = identifierValue,
+            signalType = resolvedSignalType,
+            additionalParameters = params
+        )
+        return Promise.resolved(result)
+    }
+
     /**
      * Logs an exception event with the specified message and stack information.
      *
@@ -1121,10 +1320,11 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
         const val DIALOG_CAPTURE_DELAY_MS = 500L // Configurable delay for dialog screenshot capture
 
         // Class probed at runtime to detect whether the connect-push-fcm
-        // artifact was included in the build. Conservative placeholder — the
-        // actual class name is finalised under CA-137698; if that ticket lands
-        // a different fully-qualified name, update this constant.
+        // transport artifact was included in the build (i.e. automatic mode,
+        // where Connect's own FirebaseMessagingService is the PushReceived
+        // sink). Points at the FCM messaging service shipped
+        // by the connect-push-fcm artifact.
         private const val CONNECT_PUSH_FCM_PROBE_CLASS =
-            "com.acoustic.connect.android.push.fcm.ConnectPushFcm"
+            "com.acoustic.connect.android.connectmod.push.services.fcm.FCMPushService"
     }
 }

package/ios/Bridge.h

@@ -7,7 +7,7 @@
 // prohibited.
 //
 //
-//  Created by Omar Hernandez on 5/9/25.
+//  Created on 5/9/25.
 //
 
 #pragma once

package/ios/HybridAcousticConnectRN.swift

@@ -7,7 +7,7 @@
 // prohibited.
 //
 //
-//  Created by Omar Hernandez on 5/9/25.
+//  Created on 5/9/25.
 //
 
 import Foundation
@@ -94,7 +94,7 @@ class HybridAcousticConnectRN: HybridAcousticConnectRNSpec {
     /// forwards events to the SDK; automatic/off surface `EAC-RN-007` (`false`).
     ///
     // Constructor — auto-inits the SDK from `ConnectConfig.json`. Matches the
-    // pre-CA-137696 behaviour; consumers that need consent-gated init can call
+    // pre-existing auto-init behaviour; consumers that need consent-gated init can call
     // `disable()` immediately and `enable()` once they have permission.
     override init() {
         super.init()
@@ -333,7 +333,7 @@ class HybridAcousticConnectRN: HybridAcousticConnectRNSpec {
         return true
     }
 
-    // MARK: - Push: APNs lifecycle (CA-144306)
+    // MARK: - Push: APNs lifecycle
 
     /// Forwards the raw APNs device token to the SDK. Nitro hands us native
     /// `Data` via `ArrayBuffer` — no hex conversion, no validation. Idempotent
@@ -369,7 +369,7 @@ class HybridAcousticConnectRN: HybridAcousticConnectRNSpec {
         }
     }
 
-    // MARK: - Push: notification delivery — manual mode only (CA-144307)
+    // MARK: - Push: notification delivery — manual mode only
 
     /// Forwards a received notification so the SDK logs `pushReceived` (manual
     /// mode). Resolves `true` when processed. In automatic/off mode the SDK
@@ -409,7 +409,7 @@ class HybridAcousticConnectRN: HybridAcousticConnectRNSpec {
         }
     }
 
-    // MARK: - Push: permission management (CA-144308)
+    // MARK: - Push: permission management
 
     /// Forwards externally-obtained permission state to the SDK. Tri-state
     /// `granted`: `true`/`false` forward; `nil` (notDetermined) is recorded by
@@ -575,7 +575,37 @@ class HybridAcousticConnectRN: HybridAcousticConnectRNSpec {
         let result = ConnectCustomEvent().logSignal(convertToAnyDictionary(input: values), level: logLevel)
         return result
     }
-    
+
+    /// Logs a user identity so device activity can be associated with a known
+    /// Connect contact. Wraps `ConnectSDK.shared.identity.log(...)`.
+    ///
+    /// `ConnectSDK.shared` is `@MainActor`-isolated, so — unlike the synchronous
+    /// loggers above (which use the legacy non-actor `ConnectCustomEvent`) —
+    /// this hops to the main actor and resolves with the SDK's real return
+    /// value. The native API returns `false` (and emits no signal) when either
+    /// identifier is blank, satisfying the bridge's blank-input contract without
+    /// extra guards here. `url`, if supplied, rides inside `additionalParameters`
+    /// (the iOS convention).
+    /// - Parameters:
+    ///   - identifierName: Identifier name, e.g. "Email".
+    ///   - identifierValue: Identifier value, e.g. "user@example.com".
+    ///   - signalType: Optional signal type; defaults to "loggedIn" when omitted.
+    ///   - additionalParameters: Optional extra key/value pairs merged into the
+    ///     signal. Defaults to `["registrationMethod": "email"]` only when `nil`
+    ///     (omitted); an explicit map — including an empty one — is used as-is.
+    /// - Returns: A promise resolving to `true` if the signal was dispatched,
+    ///   `false` otherwise. Never rejects.
+    func logIdentity(identifierName: String, identifierValue: String, signalType: String?, additionalParameters: [String: String]?) throws -> Promise<Bool> {
+        return Promise.async { @MainActor in
+            ConnectSDK.shared.identity.log(
+                identifierName: identifierName,
+                identifierValue: identifierValue,
+                signalType: signalType ?? "loggedIn",
+                additionalParameters: additionalParameters ?? ["registrationMethod": "email"]
+            )
+        }
+    }
+
     /// Log exception.
     /// - Parameters:
     ///   - message: the message of the error/exception to be logged this will appear in the posted json.

package/lib/commonjs/TLTRN.js

@@ -22,9 +22,25 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 
 // @ts-ignore
 
+// Preserve any previously-installed handler (e.g. React Native's red-box
+// handler) so we augment rather than replace it.
 // @ts-ignore
-global.ErrorUtils.setGlobalHandler((e, _isFatal) => {
-  _index.default.logExceptionEvent(JSON.stringify(e), JSON.stringify(e), true);
+const previousGlobalErrorHandler = global.ErrorUtils?.getGlobalHandler?.();
+
+// @ts-ignore
+global.ErrorUtils?.setGlobalHandler?.((e, isFatal) => {
+  // A global error handler must never throw — otherwise it masks the ORIGINAL
+  // error. `AcousticConnectRN` can be undefined here (e.g. the native module
+  // failed to load, or during the module-load circular import), so guard the
+  // call and always forward to the previous handler so the real error still
+  // surfaces and fatals still crash.
+  try {
+    _index.default?.logExceptionEvent?.(JSON.stringify(e), JSON.stringify(e), true);
+  } catch (loggingError) {
+    console.warn('TLTRN: failed to log uncaught exception:', loggingError?.message);
+  } finally {
+    previousGlobalErrorHandler?.(e, isFatal);
+  }
 });
 class TLTRN {
   static currentScreen = "***initialCurrentScreen not set in ConnectLogger constructor***";
@@ -249,7 +265,11 @@ class TLTRN {
       console.log("Message data:", data);
     }
     if (message.module === "ExceptionsManager") {
-      _index.default.logExceptionEvent(message.args[0], JSON.stringify(message.args[1]), true);
+      try {
+        _index.default?.logExceptionEvent?.(message.args[0], JSON.stringify(message.args[1]), true);
+      } catch (error) {
+        console.log('logExceptionEvent (bridge) error: ', error?.message);
+      }
     }
   };
   static checkTime = () => {