react-native-acoustic-connect-beta 18.0.28 → 18.0.30

package/AcousticConnectRN.podspec

@@ -2,8 +2,25 @@ require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
-# package = JSON.parse(File.read('package.json'))
-connectConfig = JSON.parse(File.read('../../ConnectConfig.json'))
+# Resolve the consumer's ConnectConfig.json from the Podfile's project root.
+#
+# Using CocoaPods' install root (the directory containing the Podfile) rather
+# than a path relative to this podspec makes config resolution correct in every
+# layout, so SDK integration is seamless for clients:
+#   - Standalone consumer: the pod lives under <app>/node_modules, the install
+#     root is <app>/ios, so <install_root>/../ConnectConfig.json resolves to
+#     <app>/ConnectConfig.json.
+#   - In-repo example apps (this monorepo's Examples/*): the install root is the
+#     example's own ios/ dir, so it resolves to that example's ConnectConfig.json
+#     instead of escaping above the repo (which a podspec-relative climb did).
+# Falls back to the legacy podspec-relative path when the install root isn't
+# available (e.g. `pod spec lint`), preserving prior behaviour.
+installRoot = (defined?(Pod::Config) && Pod::Config.instance.installation_root) || nil
+consumerConfigPath = File.join(installRoot.to_s, '..', 'ConnectConfig.json') if installRoot
+connectConfigPath =
+  (consumerConfigPath && File.exist?(consumerConfigPath)) ? consumerConfigPath
+                                                          : File.join(__dir__, '..', '..', 'ConnectConfig.json')
+connectConfig = JSON.parse(File.read(connectConfigPath))
 repository = package["repository"]["url"]
 useRelease = connectConfig["Connect"]["useRelease"]
 dependencyName = useRelease ? 'AcousticConnect' : 'AcousticConnectDebug'

package/android/build.gradle

@@ -188,6 +188,23 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "io.github.go-acoustic:$acousticArtifact:$acousticVersion"
 
+  // Firebase Cloud Messaging — required by the push variant. The
+  // `connect-push-fcm` AAR calls `com.google.firebase.messaging.*`
+  // (its `FCMPushService` extends `FirebaseMessagingService`) but its
+  // published POM does NOT declare firebase-messaging, so the transitive
+  // never arrives. Without it the push classes fail to link at runtime and
+  // push silently stays inactive — the bridge logs
+  // `connect-push-fcm on classpath: false` and no FCM token is ever
+  // requested. Gated by the same `PushEnabled` flag so analytics-only
+  // builds pull zero Firebase. The host app still supplies its own
+  // `google-services.json` and applies the `com.google.gms.google-services`
+  // plugin (the bare-workflow demo does this conditionally). The BoM aligns
+  // messaging + its installations/datatransport transitives. See CA-144314.
+  if (acousticPushEnabled) {
+    implementation platform('com.google.firebase:firebase-bom:33.7.0')
+    implementation 'com.google.firebase:firebase-messaging'
+  }
+
   // Version range enforced by the RN bridge. Lower bound prevents downgrades
   // to releases that lack APIs this bridge calls; upper bound prevents a
   // future 12.x major (with potentially breaking changes) from being picked

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

@@ -1,4 +1,4 @@
-#Fri Jun 05 01:23:00 PDT 2026
+#Thu Jun 11 03:38:51 PDT 2026
 UseWhiteList=true
 PrintScreen=3
 UseRandomSample=false

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

@@ -49,6 +49,7 @@ 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.acoustic.connect.android.connectmod.push.core.MobileServiceType
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.UIManagerHelper
@@ -156,9 +157,59 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
             Connect.init(app)
         }
         Connect.enable()
+        maybeEnablePushOnMain(app)
         Log.i(TAG, "[bridge] SDK auto-initialised at bridge construction")
     }
 
+    /**
+     * Bootstraps the native Connect push transport when the push variant is
+     * present. This is REQUIRED — it is not automatic. The `connect` /
+     * `connect-push-fcm` AARs declare no ContentProvider or `Startup`
+     * initializer, so nothing self-bootstraps `ConnectPush`. Its
+     * `enable(...)` is the sole entry point that creates the FCM
+     * [com.acoustic.connect.android.connectmod.push.PushService] transport,
+     * sets `isInitialized = true`, registers the activity-lifecycle
+     * callbacks, and constructs the `TokenUpdaterReceiver` that turns the
+     * FCM `onNewToken` broadcast into a Connect PushRegistration. Without
+     * this call the token broadcast is dropped and `sendToken()` no-ops on
+     * `isInitialized == false`, so no registration ever reaches Connect.
+     *
+     * Gated by [isConnectPushFcmAvailable] so analytics-only
+     * (`PushEnabled=false`) builds — which bundle no Firebase — never touch
+     * the FCM transport classes. Idempotent: short-circuits once
+     * `Connect.push.isInitialized()` is true, so it is safe to call from
+     * every init path (construction auto-init, JS `enable()`, lifecycle
+     * resume). `MobileServiceType.FCM` is hard-coded: FCM is the only push
+     * provider on the JS surface (HMS was dropped — see deviation 4).
+     *
+     * MUST be called on the main looper, after `Connect.enable()`.
+     */
+    private fun maybeEnablePushOnMain(application: Application) {
+        if (!isConnectPushFcmAvailable()) return
+        if (Connect.push.isInitialized()) return
+        val smallIconRes = resolvePushSmallIconRes(application)
+        Connect.push.enable(application, true, smallIconRes, MobileServiceType.FCM) { e ->
+            Log.w(TAG, "[bridge] push enable failed — ${e.message}")
+        }
+        Log.i(TAG, "[bridge] Connect push transport enabled (FCM)")
+    }
+
+    /**
+     * Resolves the status-bar notification small-icon drawable for push.
+     * Looks up `ic_stat_push` (the demo's committed monochrome icon, also
+     * the `AndroidNotificationIconResName` convention) and falls back to the
+     * app's launcher icon when absent, so consumers that didn't add a
+     * dedicated push icon still get a valid resource rather than `0`.
+     */
+    private fun resolvePushSmallIconRes(application: Application): Int {
+        val byName = application.resources.getIdentifier(
+            "ic_stat_push",
+            "drawable",
+            application.packageName,
+        )
+        return if (byName != 0) byName else application.applicationInfo.icon
+    }
+
     /**
      * Resolves the host app's `Application` from
      * `NitroModules.applicationContext`. Returns `null` (with a logged
@@ -214,6 +265,7 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
             }
             Connect.init(application)
             Connect.enable()
+            maybeEnablePushOnMain(application)
             Log.i(TAG, "[bridge] SDK initialised")
         }
         return true
@@ -235,31 +287,40 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
 
     // region Push (Android)
     //
-    // 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:
+    // The shared Nitro spec declares these push methods on both platforms.
+    // Once the bridge bootstraps the native push transport via
+    // [maybeEnablePushOnMain] (`Connect.push.enable(..., MobileServiceType.FCM)`
+    // at SDK init), the native SDK owns the rest of the push lifecycle:
+    // Connect's own FirebaseMessagingService (shipped in connect-push-fcm)
+    // handles inbound delivery and PushReceived / PushAction logging, and the
+    // `TokenUpdaterReceiver` registered by `enable(...)` turns the FCM
+    // `onNewToken` broadcast into a Connect PushRegistration. That bootstrap
+    // is NOT automatic — the AARs declare no ContentProvider / Startup
+    // initializer, so without the `enable(...)` call no token ever registers.
+    //
+    // After bootstrap there is no manual JS-forwarding API on Android (unlike
+    // iOS), so every JS→native forwarder below 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:
+    // The only Android-relevant runtime interaction 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.
+    // parked (the native transport registers the token with Connect once
+    // enabled; 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.
+     * iOS-primary forwarder. On Android the FCM token is captured and
+     * registered with Connect by the native transport once it is bootstrapped
+     * via [maybeEnablePushOnMain] (the `TokenUpdaterReceiver` set up by
+     * `Connect.push.enable(...)` consumes the `onNewToken` broadcast), so this
+     * JS forwarder is a no-op that reports "handled". Never rejects.
      */
     override fun pushDidRegisterWithToken(deviceToken: ArrayBuffer): Promise<Boolean> {
-        Log.d(TAG, "[bridge] pushDidRegisterWithToken: no-op on Android (native SDK owns token registration)")
+        Log.d(TAG, "[bridge] pushDidRegisterWithToken: no-op on Android (native transport owns token registration once enabled)")
         return Promise.resolved(true)
     }
 
@@ -619,6 +680,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.
      *
@@ -1237,6 +1344,7 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
             // call the native SDK's `Connect.enable()` directly so the
             // log line "called from JS" doesn't fire on lifecycle wake-ups.
             Connect.enable()
+            resolveApplication()?.let { maybeEnablePushOnMain(it) }
         }
         onResume(activity, null)
     }

package/ios/AcousticConnectRNConfig.json

@@ -1,10 +1,14 @@
 {
   "Connect": {
-    "AndroidVersion": "11.0.12-beta",
     "AppKey": "b6c3709b7a4c479bb4b5a9fb8fec324c",
     "KillSwitchUrl": "https://lib-us-2.brilliantcollector.com/collector/switch/b6c3709b7a4c479bb4b5a9fb8fec324c",
     "PostMessageUrl": "https://lib-us-2.brilliantcollector.com/collector/collectorPost",
+    "AndroidVersion": "",
     "iOSVersion": "",
+    "PushEnabled": false,
+    "iOSPushMode": "automatic",
+    "iOSAppGroupIdentifier": null,
+    "AndroidNotificationIconResName": null,
     "layoutConfigAndroid": {
       "AppendMapIds": {
         "[w,9290],[v,0]": {

package/ios/HybridAcousticConnectRN.swift

@@ -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/typescript/src/specs/react-native-acoustic-connect.nitro.d.ts

@@ -122,6 +122,46 @@ export interface AcousticConnectRN extends HybridObject<{
     logDialogDismissEvent(dialogId: string, dismissReason: string): boolean;
     logDialogButtonClickEvent(dialogId: string, buttonText: string, buttonIndex: number): boolean;
     logDialogCustomEvent(dialogId: string, eventName: string, values: Record<string, string | number | boolean>): boolean;
+    /**
+     * Logs a user identity so the current device/session can be associated with
+     * a known Connect contact — the foundation for audience building and
+     * cross-channel engagement. Wraps the native identity loggers
+     * (`ConnectSDK.shared.identity.log` on iOS, `Connect.logIdentificationEvent`
+     * on Android).
+     *
+     * Unlike the synchronous analytics loggers above, this returns a `Promise`:
+     * `ConnectSDK.shared` (iOS) is `@MainActor`-isolated, so the bridge hops to the
+     * main actor and resolves with the *real* success/failure value rather than
+     * firing and forgetting.
+     *
+     * The native APIs return `false` — and emit no signal — when either
+     * `identifierName` or `identifierValue` is empty/blank after trimming.
+     *
+     * @param identifierName  Identifier name, e.g. `'Email'`.
+     * @param identifierValue Identifier value, e.g. `'user@example.com'`.
+     * @param signalType      Optional signal type; the bridge supplies
+     *   `'loggedIn'` when omitted (identity logging typically marks a sign-in),
+     *   overriding the native SDKs' own `'pageView'` default.
+     * @param additionalParameters Optional extra key/value pairs merged into the
+     *   signal payload. Only when omitted (`undefined`) does the bridge supply
+     *   the default `{ registrationMethod: 'email' }`; an explicitly-provided
+     *   map is used as-is, so passing an empty `{}` sends no extra parameters
+     *   (the default is not merged in). A `'url'` entry is honoured uniformly on
+     *   both platforms: on Android it is routed to the SDK's explicit `url`
+     *   parameter, on iOS it rides inside the parameter map (where the native
+     *   API expects it).
+     * @returns A promise resolving to `true` if the identity signal was
+     *   dispatched, `false` otherwise (including the blank-identifier case).
+     *   Never rejects.
+     *
+     * @example
+     * ```ts
+     * import AcousticConnectRN from 'react-native-acoustic-connect-beta'
+     *
+     * await AcousticConnectRN.logIdentity('Email', 'user@example.com')
+     * ```
+     */
+    logIdentity(identifierName: string, identifierValue: string, signalType?: string, additionalParameters?: Record<string, string>): Promise<boolean>;
     /**
      * Forwards the raw APNs device token to the Connect SDK (manual mode).
      *

package/lib/typescript/src/specs/react-native-acoustic-connect.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"react-native-acoustic-connect.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/react-native-acoustic-connect.nitro.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"react-native-acoustic-connect.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/react-native-acoustic-connect.nitro.ts"],"names":[],"mappings":"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"}

package/nitrogen/generated/android/c++/JHybridAcousticConnectRNSpec.cpp

@@ -201,6 +201,28 @@ namespace margelo::nitro::acousticconnectrn {
     }());
     return static_cast<bool>(__result);
   }
+  std::shared_ptr<Promise<bool>> JHybridAcousticConnectRNSpec::logIdentity(const std::string& identifierName, const std::string& identifierValue, const std::optional<std::string>& signalType, const std::optional<std::unordered_map<std::string, std::string>>& additionalParameters) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* identifierName */, jni::alias_ref<jni::JString> /* identifierValue */, jni::alias_ref<jni::JString> /* signalType */, jni::alias_ref<jni::JMap<jni::JString, jni::JString>> /* additionalParameters */)>("logIdentity");
+    auto __result = method(_javaPart, jni::make_jstring(identifierName), jni::make_jstring(identifierValue), signalType.has_value() ? jni::make_jstring(signalType.value()) : nullptr, additionalParameters.has_value() ? [&]() -> jni::local_ref<jni::JMap<jni::JString, jni::JString>> {
+      auto __map = jni::JHashMap<jni::JString, jni::JString>::create(additionalParameters.value().size());
+      for (const auto& __entry : additionalParameters.value()) {
+        __map->put(jni::make_jstring(__entry.first), jni::make_jstring(__entry.second));
+      }
+      return __map;
+    }() : nullptr);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
   std::shared_ptr<Promise<bool>> JHybridAcousticConnectRNSpec::pushDidRegisterWithToken(const std::shared_ptr<ArrayBuffer>& deviceToken) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JArrayBuffer::javaobject> /* deviceToken */)>("pushDidRegisterWithToken");
     auto __result = method(_javaPart, JArrayBuffer::wrap(deviceToken));

package/nitrogen/generated/android/c++/JHybridAcousticConnectRNSpec.hpp

@@ -78,6 +78,7 @@ namespace margelo::nitro::acousticconnectrn {
     bool logDialogDismissEvent(const std::string& dialogId, const std::string& dismissReason) override;
     bool logDialogButtonClickEvent(const std::string& dialogId, const std::string& buttonText, double buttonIndex) override;
     bool logDialogCustomEvent(const std::string& dialogId, const std::string& eventName, const std::unordered_map<std::string, std::variant<bool, std::string, double>>& values) override;
+    std::shared_ptr<Promise<bool>> logIdentity(const std::string& identifierName, const std::string& identifierValue, const std::optional<std::string>& signalType, const std::optional<std::unordered_map<std::string, std::string>>& additionalParameters) override;
     std::shared_ptr<Promise<bool>> pushDidRegisterWithToken(const std::shared_ptr<ArrayBuffer>& deviceToken) override;
     std::shared_ptr<Promise<bool>> pushDidFailToRegister(const PushErrorInfo& error) override;
     std::shared_ptr<Promise<bool>> pushDidReceiveNotification(const std::unordered_map<std::string, std::variant<bool, std::string, double>>& userInfo) override;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/acousticconnectrn/HybridAcousticConnectRNSpec.kt

@@ -127,6 +127,10 @@ abstract class HybridAcousticConnectRNSpec: HybridObject() {
   @Keep
   abstract fun logDialogCustomEvent(dialogId: String, eventName: String, values: Map<String, Variant_Boolean_String_Double>): Boolean
   
+  @DoNotStrip
+  @Keep
+  abstract fun logIdentity(identifierName: String, identifierValue: String, signalType: String?, additionalParameters: Map<String, String>?): Promise<Boolean>
+  
   @DoNotStrip
   @Keep
   abstract fun pushDidRegisterWithToken(deviceToken: ArrayBuffer): Promise<Boolean>

package/nitrogen/generated/ios/AcousticConnectRN-Swift-Cxx-Bridge.hpp

@@ -201,33 +201,73 @@ namespace margelo::nitro::acousticconnectrn::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<double>
+  // pragma MARK: std::optional<std::string>
   /**
-   * Specialized version of `std::optional<double>`.
+   * Specialized version of `std::optional<std::string>`.
    */
-  using std__optional_double_ = std::optional<double>;
-  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
-    return std::optional<double>(value);
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
   }
-  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
     return optional.has_value();
   }
-  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
     return optional.value();
   }
   
-  // pragma MARK: std::optional<std::string>
+  // pragma MARK: std::unordered_map<std::string, std::string>
   /**
-   * Specialized version of `std::optional<std::string>`.
+   * Specialized version of `std::unordered_map<std::string, std::string>`.
    */
-  using std__optional_std__string_ = std::optional<std::string>;
-  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
-    return std::optional<std::string>(value);
+  using std__unordered_map_std__string__std__string_ = std::unordered_map<std::string, std::string>;
+  inline std::unordered_map<std::string, std::string> create_std__unordered_map_std__string__std__string_(size_t size) noexcept {
+    std::unordered_map<std::string, std::string> map;
+    map.reserve(size);
+    return map;
   }
-  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+  inline std::vector<std::string> get_std__unordered_map_std__string__std__string__keys(const std__unordered_map_std__string__std__string_& map) noexcept {
+    std::vector<std::string> keys;
+    keys.reserve(map.size());
+    for (const auto& entry : map) {
+      keys.push_back(entry.first);
+    }
+    return keys;
+  }
+  inline std::string get_std__unordered_map_std__string__std__string__value(const std__unordered_map_std__string__std__string_& map, const std::string& key) noexcept {
+    return map.find(key)->second;
+  }
+  inline void emplace_std__unordered_map_std__string__std__string_(std__unordered_map_std__string__std__string_& map, const std::string& key, const std::string& value) noexcept {
+    map.emplace(key, value);
+  }
+  
+  // pragma MARK: std::optional<std::unordered_map<std::string, std::string>>
+  /**
+   * Specialized version of `std::optional<std::unordered_map<std::string, std::string>>`.
+   */
+  using std__optional_std__unordered_map_std__string__std__string__ = std::optional<std::unordered_map<std::string, std::string>>;
+  inline std::optional<std::unordered_map<std::string, std::string>> create_std__optional_std__unordered_map_std__string__std__string__(const std::unordered_map<std::string, std::string>& value) noexcept {
+    return std::optional<std::unordered_map<std::string, std::string>>(value);
+  }
+  inline bool has_value_std__optional_std__unordered_map_std__string__std__string__(const std::optional<std::unordered_map<std::string, std::string>>& optional) noexcept {
     return optional.has_value();
   }
-  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+  inline std::unordered_map<std::string, std::string> get_std__optional_std__unordered_map_std__string__std__string__(const std::optional<std::unordered_map<std::string, std::string>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
+    return std::optional<double>(value);
+  }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
     return optional.value();
   }
   

package/nitrogen/generated/ios/c++/HybridAcousticConnectRNSpecSwift.hpp

@@ -272,6 +272,14 @@ namespace margelo::nitro::acousticconnectrn {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<bool>> logIdentity(const std::string& identifierName, const std::string& identifierValue, const std::optional<std::string>& signalType, const std::optional<std::unordered_map<std::string, std::string>>& additionalParameters) override {
+      auto __result = _swiftPart.logIdentity(identifierName, identifierValue, signalType, additionalParameters);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<bool>> pushDidRegisterWithToken(const std::shared_ptr<ArrayBuffer>& deviceToken) override {
       auto __result = _swiftPart.pushDidRegisterWithToken(ArrayBufferHolder(deviceToken));
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/HybridAcousticConnectRNSpec.swift

@@ -37,6 +37,7 @@ public protocol HybridAcousticConnectRNSpec_protocol: HybridObject {
   func logDialogDismissEvent(dialogId: String, dismissReason: String) throws -> Bool
   func logDialogButtonClickEvent(dialogId: String, buttonText: String, buttonIndex: Double) throws -> Bool
   func logDialogCustomEvent(dialogId: String, eventName: String, values: Dictionary<String, Variant_Bool_String_Double>) throws -> Bool
+  func logIdentity(identifierName: String, identifierValue: String, signalType: String?, additionalParameters: Dictionary<String, String>?) throws -> Promise<Bool>
   func pushDidRegisterWithToken(deviceToken: ArrayBuffer) throws -> Promise<Bool>
   func pushDidFailToRegister(error: PushErrorInfo) throws -> Promise<Bool>
   func pushDidReceiveNotification(userInfo: Dictionary<String, Variant_Bool_String_Double>) throws -> Promise<Bool>

package/nitrogen/generated/ios/swift/HybridAcousticConnectRNSpec_cxx.swift

@@ -604,6 +604,47 @@ open class HybridAcousticConnectRNSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func logIdentity(identifierName: std.string, identifierValue: std.string, signalType: bridge.std__optional_std__string_, additionalParameters: bridge.std__optional_std__unordered_map_std__string__std__string__) -> bridge.Result_std__shared_ptr_Promise_bool___ {
+    do {
+      let __result = try self.__implementation.logIdentity(identifierName: String(identifierName), identifierValue: String(identifierValue), signalType: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(signalType) {
+          let __unwrapped = bridge.get_std__optional_std__string_(signalType)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }(), additionalParameters: { () -> Dictionary<String, String>? in
+        if bridge.has_value_std__optional_std__unordered_map_std__string__std__string__(additionalParameters) {
+          let __unwrapped = bridge.get_std__optional_std__unordered_map_std__string__std__string__(additionalParameters)
+          return { () -> Dictionary<String, String> in
+            var __dictionary = Dictionary<String, String>(minimumCapacity: __unwrapped.size())
+            let __keys = bridge.get_std__unordered_map_std__string__std__string__keys(__unwrapped)
+            for __key in __keys {
+              let __value = bridge.get_std__unordered_map_std__string__std__string__value(__unwrapped, __key)
+              __dictionary[String(__key)] = String(__value)
+            }
+            return __dictionary
+          }()
+        } else {
+          return nil
+        }
+      }())
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func pushDidRegisterWithToken(deviceToken: ArrayBuffer) -> bridge.Result_std__shared_ptr_Promise_bool___ {
     do {

package/nitrogen/generated/shared/c++/HybridAcousticConnectRNSpec.cpp

@@ -38,6 +38,7 @@ namespace margelo::nitro::acousticconnectrn {
       prototype.registerHybridMethod("logDialogDismissEvent", &HybridAcousticConnectRNSpec::logDialogDismissEvent);
       prototype.registerHybridMethod("logDialogButtonClickEvent", &HybridAcousticConnectRNSpec::logDialogButtonClickEvent);
       prototype.registerHybridMethod("logDialogCustomEvent", &HybridAcousticConnectRNSpec::logDialogCustomEvent);
+      prototype.registerHybridMethod("logIdentity", &HybridAcousticConnectRNSpec::logIdentity);
       prototype.registerHybridMethod("pushDidRegisterWithToken", &HybridAcousticConnectRNSpec::pushDidRegisterWithToken);
       prototype.registerHybridMethod("pushDidFailToRegister", &HybridAcousticConnectRNSpec::pushDidFailToRegister);
       prototype.registerHybridMethod("pushDidReceiveNotification", &HybridAcousticConnectRNSpec::pushDidReceiveNotification);

package/nitrogen/generated/shared/c++/HybridAcousticConnectRNSpec.hpp

@@ -83,6 +83,7 @@ namespace margelo::nitro::acousticconnectrn {
       virtual bool logDialogDismissEvent(const std::string& dialogId, const std::string& dismissReason) = 0;
       virtual bool logDialogButtonClickEvent(const std::string& dialogId, const std::string& buttonText, double buttonIndex) = 0;
       virtual bool logDialogCustomEvent(const std::string& dialogId, const std::string& eventName, const std::unordered_map<std::string, std::variant<bool, std::string, double>>& values) = 0;
+      virtual std::shared_ptr<Promise<bool>> logIdentity(const std::string& identifierName, const std::string& identifierValue, const std::optional<std::string>& signalType, const std::optional<std::unordered_map<std::string, std::string>>& additionalParameters) = 0;
       virtual std::shared_ptr<Promise<bool>> pushDidRegisterWithToken(const std::shared_ptr<ArrayBuffer>& deviceToken) = 0;
       virtual std::shared_ptr<Promise<bool>> pushDidFailToRegister(const PushErrorInfo& error) = 0;
       virtual std::shared_ptr<Promise<bool>> pushDidReceiveNotification(const std::unordered_map<std::string, std::variant<bool, std::string, double>>& userInfo) = 0;

package/package.json

@@ -195,7 +195,7 @@
     "source": "src/index",
     "summary": "react-native ios android tealeaf connect cxa wxca er enhanced-replay",
     "types": "./lib/typescript/src/index.d.ts",
-    "version": "18.0.28",
+    "version": "18.0.30",
     "workspaces": [
         "example",
         "Examples/bare-workflow"

package/src/specs/react-native-acoustic-connect.nitro.ts

@@ -140,6 +140,52 @@ export interface AcousticConnectRN extends HybridObject<{ ios: 'swift', android:
     logDialogButtonClickEvent(dialogId: string, buttonText: string, buttonIndex: number): boolean
     logDialogCustomEvent(dialogId: string, eventName: string, values: Record<string, string | number | boolean>): boolean
 
+    /**
+     * Logs a user identity so the current device/session can be associated with
+     * a known Connect contact — the foundation for audience building and
+     * cross-channel engagement. Wraps the native identity loggers
+     * (`ConnectSDK.shared.identity.log` on iOS, `Connect.logIdentificationEvent`
+     * on Android).
+     *
+     * Unlike the synchronous analytics loggers above, this returns a `Promise`:
+     * `ConnectSDK.shared` (iOS) is `@MainActor`-isolated, so the bridge hops to the
+     * main actor and resolves with the *real* success/failure value rather than
+     * firing and forgetting.
+     *
+     * The native APIs return `false` — and emit no signal — when either
+     * `identifierName` or `identifierValue` is empty/blank after trimming.
+     *
+     * @param identifierName  Identifier name, e.g. `'Email'`.
+     * @param identifierValue Identifier value, e.g. `'user@example.com'`.
+     * @param signalType      Optional signal type; the bridge supplies
+     *   `'loggedIn'` when omitted (identity logging typically marks a sign-in),
+     *   overriding the native SDKs' own `'pageView'` default.
+     * @param additionalParameters Optional extra key/value pairs merged into the
+     *   signal payload. Only when omitted (`undefined`) does the bridge supply
+     *   the default `{ registrationMethod: 'email' }`; an explicitly-provided
+     *   map is used as-is, so passing an empty `{}` sends no extra parameters
+     *   (the default is not merged in). A `'url'` entry is honoured uniformly on
+     *   both platforms: on Android it is routed to the SDK's explicit `url`
+     *   parameter, on iOS it rides inside the parameter map (where the native
+     *   API expects it).
+     * @returns A promise resolving to `true` if the identity signal was
+     *   dispatched, `false` otherwise (including the blank-identifier case).
+     *   Never rejects.
+     *
+     * @example
+     * ```ts
+     * import AcousticConnectRN from 'react-native-acoustic-connect-beta'
+     *
+     * await AcousticConnectRN.logIdentity('Email', 'user@example.com')
+     * ```
+     */
+    logIdentity(
+        identifierName: string,
+        identifierValue: string,
+        signalType?: string,
+        additionalParameters?: Record<string, string>
+    ): Promise<boolean>
+
     // ── Push: APNs lifecycle (iOS) ──────────────────────────────────────────
     //
     // Push mode (automatic / manual / off) is configured in `ConnectConfig.json`