react-native-sdk-pianoio 0.4.5 → 0.4.6

package/android/src/main/java/com/sdkpianoio/ComposerPianoImpl.kt

@@ -273,19 +273,23 @@ class ComposerPianoImpl {
     // MARK: - Configuration Methods (Setters)
 
     fun addTag(tag: String) {
-        Log.d(TAG, "Adding tag: $tag")
+        Log.d(TAG, "[addTag] Adding tag: '$tag'")
         if (!this.tags.contains(tag)) {
             this.tags.add(tag)
+            Log.d(TAG, "[addTag] Tag added. Current tags: [${this.tags.joinToString(", ")}]")
+        } else {
+            Log.d(TAG, "[addTag] Tag already exists. Current tags: [${this.tags.joinToString(", ")}]")
         }
     }
 
     fun addTags(tags: List<String>) {
-        Log.d(TAG, "Adding tags: $tags")
+        Log.d(TAG, "[addTags] Adding tags: [${tags.joinToString(", ")}]")
         for (tag in tags) {
             if (!this.tags.contains(tag)) {
                 this.tags.add(tag)
             }
         }
+        Log.d(TAG, "[addTags] Tags after addition: [${this.tags.joinToString(", ")}] (count: ${this.tags.size})")
     }
 
     fun setZoneId(zoneId: String) {
@@ -323,33 +327,36 @@ class ComposerPianoImpl {
     // MARK: - Cleanup Methods
 
     fun clearTags() {
-        Log.d(TAG, "Clearing tags")
+        Log.d(TAG, "[clearTags] Clearing all tags. Current tags before clear: [${this.tags.joinToString(", ")}] (count: ${this.tags.size})")
         this.tags.clear()
+        Log.d(TAG, "[clearTags] Tags cleared. Current tags after clear: [${this.tags.joinToString(", ")}] (count: ${this.tags.size})")
     }
 
     fun clearCustomVariables() {
-        Log.d(TAG, "Clearing custom variables")
+        Log.d(TAG, "[clearCustomVariables] Clearing custom variables")
         this.customVariables.clear()
     }
 
     fun removeTag(tag: String) {
-        Log.d(TAG, "Removing tag: $tag")
-        this.tags.remove(tag)
+        Log.d(TAG, "[removeTag] Removing tag: '$tag'. Tags before: [${this.tags.joinToString(", ")}]")
+        val removed = this.tags.remove(tag)
+        Log.d(TAG, "[removeTag] Tag removed: $removed. Tags after: [${this.tags.joinToString(", ")}]")
     }
 
     fun removeCustomVariable(key: String) {
-        Log.d(TAG, "Removing custom variable: $key")
+        Log.d(TAG, "[removeCustomVariable] Removing custom variable: $key")
         this.customVariables.remove(key)
     }
 
     fun clearConfiguration() {
-        Log.d(TAG, "Clearing all configurations")
+        Log.d(TAG, "[clearConfiguration] Clearing all configurations")
         this.clearTags()
         this.clearCustomVariables()
         this.zoneId = null
         this.referrer = null
         this.url = null
         this.userToken = null
+        Log.d(TAG, "[clearConfiguration] All configurations cleared")
     }
 
     // MARK: - Execution Methods
@@ -361,13 +368,18 @@ class ComposerPianoImpl {
      * @throws IllegalStateException if the composer has not been initialized.
      */
     fun executeComposer(promise: Promise) {
+        Log.d(TAG, "")
+        Log.d(TAG, "=".repeat(80))
         Log.d(TAG, "=== STARTING COMPOSER EXECUTION ===")
+        Log.d(TAG, "=".repeat(80))
         Log.d(TAG, "Current configuration:")
         Log.d(TAG, "  - AID: ${ComposerPianoImpl.aid}")
-        Log.d(TAG, "  - Tags: ${this.tags}")
-        Log.d(TAG, "  - Zone ID: ${this.zoneId}")
-        Log.d(TAG, "  - Referrer: ${this.referrer}")
-        Log.d(TAG, "  - URL: ${this.url}")
+        Log.d(TAG, "  - Tags count: ${this.tags.size}")
+        Log.d(TAG, "  - Tags: [${this.tags.joinToString(", ")}]")
+        Log.d(TAG, "  - Tags detail: ${this.tags}")
+        Log.d(TAG, "  - Zone ID: ${this.zoneId ?: "(not set)"}")
+        Log.d(TAG, "  - Referrer: ${this.referrer ?: "(not set)"}")
+        Log.d(TAG, "  - URL: ${this.url ?: "(not set)"}")
         Log.d(TAG, "  - User Token: ${if (userToken != null) "Set" else "Not set"}")
         Log.d(TAG, "  - Custom Variables: ${this.customVariables}")
 
@@ -390,6 +402,13 @@ class ComposerPianoImpl {
                 customParams.request(key, value)
             }
 
+            Log.d(TAG, "")
+            Log.d(TAG, ">>> BUILDING EXPERIENCE REQUEST <<<")
+            Log.d(TAG, ">>> Tags being passed to ExperienceRequest.Builder(): [${this.tags.joinToString(", ")}]")
+            Log.d(TAG, ">>> Tags count: ${this.tags.size}")
+            Log.d(TAG, ">>> ⚠️  IF TAGS APPEAR HERE AFTER clearTags(), THE BUG IS IN THE WRAPPER")
+            Log.d(TAG, ">>> ⚠️  IF TAGS APPEAR IN PIANO REQUEST BUT NOT HERE, THE BUG IS IN PIANO SDK")
+
             val request =
                     ExperienceRequest.Builder()
                             .tags(this.tags)
@@ -399,7 +418,11 @@ class ComposerPianoImpl {
                             .customParams(customParams)
                             .debug(true)  // Enable debug mode for more logging
                             .build()
-            Log.d(TAG, "ExperienceRequest created with debug mode ON")
+            Log.d(TAG, "✓ ExperienceRequest created with debug mode ON")
+            Log.d(TAG, "⚠️  NOTE: Piano Composer SDK does NOT provide getters to verify internal state")
+            Log.d(TAG, "⚠️  We can only verify OUR wrapper state, not Piano's singleton state")
+            Log.d(TAG, "⚠️  If bug exists, it's in Piano SDK's internal tag management")
+            Log.d(TAG, "=".repeat(80))
 
             // Collect all events instead of resolving on first event
             val collectedEvents = mutableListOf<WritableMap>()

package/ios/ComposerPianoImpl.swift

@@ -2,6 +2,7 @@ import Foundation
 import PianoComposer
 import PianoOAuth
 import React
+import os.log
 
 /// ComposerPianoImpl - Main implementation class for the Piano SDK on iOS.
 @objcMembers public class ComposerPianoImpl: NSObject {
@@ -32,27 +33,27 @@ import React
      * @throws Error if initialization fails
      */
     public func initialize(aid: String, isSandbox: Bool) throws {
-        print("[ComposerPianoImpl] Initializing with AID: \(aid), isSandbox: \(isSandbox)")
+        NSLog("[ComposerPianoImpl] Initializing with AID: \(aid), isSandbox: \(isSandbox)")
 
         // Validate input parameter
         guard !aid.isEmpty else {
-            print("[ComposerPianoImpl] ERROR: AID cannot be empty")
+            NSLog("[ComposerPianoImpl] ERROR: AID cannot be empty")
             throw NSError(domain: "PianoSDK", code: -1, userInfo: [NSLocalizedDescriptionKey: "AID cannot be empty"])
         }
 
         // Store the AID
         self.aid = aid
-        print("[ComposerPianoImpl] AID stored: \(aid)")
+        NSLog("[ComposerPianoImpl] AID stored: \(aid)")
 
         do {
             // 1. Initialize and store the TokenService
             self.tokenService = TokenService()
             self.tokenService?.initialize(aid: aid, isSandbox: isSandbox)
-            print("[ComposerPianoImpl] TokenService initialized with sandbox=\(isSandbox)")
+            NSLog("[ComposerPianoImpl] TokenService initialized with sandbox=\(isSandbox)")
 
             // 2. Initialize the Composer instance
             let endpoint = isSandbox ? PianoEndpoint.sandbox : PianoEndpoint.production
-            print("[ComposerPianoImpl] Using endpoint: \(endpoint)")
+            NSLog("[ComposerPianoImpl] Using endpoint: \(endpoint)")
             self.composer = PianoComposer(aid: aid, endpoint: endpoint)
 
             guard self.composer != nil else {
@@ -62,10 +63,10 @@ import React
             // 3. Initialize and set up the delegate
             self.delegate = MyComposerDelegate(impl: self)
             self.composer?.delegate = self.delegate
-            print("[ComposerPianoImpl] Delegate initialized and set")
-            print("[ComposerPianoImpl] Initialization completed successfully")
+            NSLog("[ComposerPianoImpl] Delegate initialized and set")
+            NSLog("[ComposerPianoImpl] Initialization completed successfully")
         } catch {
-            print("[ComposerPianoImpl] Error during initialization: \(error.localizedDescription)")
+            NSLog("[ComposerPianoImpl] Error during initialization: \(error.localizedDescription)")
             throw error
         }
     }
@@ -103,42 +104,52 @@ import React
     // MARK: - Configuration Methods (Setters)
 
     public func addTag(_ tag: String) {
-        print("[ComposerPianoImpl] Adding tag: \(tag)")
-        self.tags.append(tag)
+        NSLog("[ComposerPianoImpl] [addTag] Adding tag: '\(tag)'")
+        if !self.tags.contains(tag) {
+            self.tags.append(tag)
+            NSLog("[ComposerPianoImpl] [addTag] Tag added. Current tags: [\(self.tags.joined(separator: ", "))]")
+        } else {
+            NSLog("[ComposerPianoImpl] [addTag] Tag already exists. Current tags: [\(self.tags.joined(separator: ", "))]")
+        }
     }
 
     public func addTags(_ tags: [String]) {
-        print("[ComposerPianoImpl] Adding tags: \(tags)")
-        self.tags.append(contentsOf: tags)
+        NSLog("[ComposerPianoImpl] [addTags] Adding tags: [\(tags.joined(separator: ", "))]")
+        for tag in tags {
+            if !self.tags.contains(tag) {
+                self.tags.append(tag)
+            }
+        }
+        NSLog("[ComposerPianoImpl] [addTags] Tags after addition: [\(self.tags.joined(separator: ", "))] (count: \(self.tags.count))")
     }
 
     public func setZoneId(_ zoneId: String) {
-        print("[ComposerPianoImpl] Setting zoneId: \(zoneId)")
+        NSLog("[ComposerPianoImpl] Setting zoneId: \(zoneId)")
         self.zoneId = zoneId
     }
 
     public func setReferrer(_ referrer: String) {
-        print("[ComposerPianoImpl] Setting referrer: \(referrer)")
+        NSLog("[ComposerPianoImpl] Setting referrer: \(referrer)")
         self.referrer = referrer
     }
 
     public func setUrl(_ url: String) {
-        print("[ComposerPianoImpl] Setting url: \(url)")
+        NSLog("[ComposerPianoImpl] Setting url: \(url)")
         self.url = url
     }
     
     public func setCustomVariables(_ variables: [String: String]) {
-        print("[ComposerPianoImpl] Setting custom variables")
+        NSLog("[ComposerPianoImpl] Setting custom variables")
         self.customVariables = variables
     }
 
     public func addCustomVariable(_ name: String, value: String) {
-        print("[ComposerPianoImpl] Adding custom variable: \(name) = \(value)")
+        NSLog("[ComposerPianoImpl] Adding custom variable: \(name) = \(value)")
         self.customVariables[name] = value
     }
 
     public func setUserToken(_ token: String) {
-        print("[ComposerPianoImpl] Setting userToken")
+        NSLog("[ComposerPianoImpl] Setting userToken")
         self.userToken = token
         _ = self.composer?.userToken(token)
     }
@@ -146,29 +157,36 @@ import React
     // MARK: - Cleanup Methods
 
     public func clearTags() {
+        NSLog("[ComposerPianoImpl] [clearTags] Clearing all tags. Current tags before clear: [\(self.tags.joined(separator: ", "))] (count: \(self.tags.count))")
         self.tags.removeAll()
+        NSLog("[ComposerPianoImpl] [clearTags] Tags cleared. Current tags after clear: [\(self.tags.joined(separator: ", "))] (count: \(self.tags.count))")
     }
 
     public func clearCustomVariables() {
+        NSLog("[ComposerPianoImpl] [clearCustomVariables] Clearing custom variables")
         self.customVariables.removeAll()
     }
 
     public func removeTag(_ tag: String) {
+        NSLog("[ComposerPianoImpl] [removeTag] Removing tag: '\(tag)'. Tags before: [\(self.tags.joined(separator: ", "))]")
         self.tags.removeAll { $0 == tag }
+        NSLog("[ComposerPianoImpl] [removeTag] Tags after: [\(self.tags.joined(separator: ", "))]")
     }
 
     public func removeCustomVariable(key: String) {
+        NSLog("[ComposerPianoImpl] [removeCustomVariable] Removing custom variable: \(key)")
         self.customVariables.removeValue(forKey: key)
     }
 
     public func clearConfiguration() {
-        print("[ComposerPianoImpl] Clearing all configurations")
+        NSLog("[ComposerPianoImpl] [clearConfiguration] Clearing all configurations")
         self.clearTags()
         self.clearCustomVariables()
         self.zoneId = nil
         self.referrer = nil
         self.url = nil
         self.userToken = nil
+        NSLog("[ComposerPianoImpl] [clearConfiguration] All configurations cleared")
     }
 
     // MARK: - Execution Method
@@ -178,20 +196,25 @@ import React
         rejecter: @escaping RCTPromiseRejectBlock
     ) {
         guard let composer = self.composer else {
-            print("[ComposerPianoImpl] ERROR: executeExperience called but composer is not initialized.")
+            NSLog("[ComposerPianoImpl] ERROR: executeExperience called but composer is not initialized.")
             rejecter("INIT_ERROR", "Composer not initialized.", nil)
             return
         }
 
-        print("[ComposerPianoImpl] === STARTING COMPOSER EXECUTION ===")
-        print("[ComposerPianoImpl] Current configuration:")
-        print("[ComposerPianoImpl]   - AID: \(self.aid ?? "nil")")
-        print("[ComposerPianoImpl]   - Tags: \(self.tags)")
-        print("[ComposerPianoImpl]   - Zone ID: \(self.zoneId ?? "nil")")
-        print("[ComposerPianoImpl]   - Referrer: \(self.referrer ?? "nil")")
-        print("[ComposerPianoImpl]   - URL: \(self.url ?? "nil")")
-        print("[ComposerPianoImpl]   - User Token: \(self.userToken != nil ? "Set" : "Not set")")
-        print("[ComposerPianoImpl]   - Custom Variables: \(self.customVariables)")
+        NSLog("")
+        NSLog(String(repeating: "=", count: 80))
+        NSLog("[ComposerPianoImpl] === STARTING COMPOSER EXECUTION ===")
+        NSLog(String(repeating: "=", count: 80))
+        NSLog("[ComposerPianoImpl] Current configuration:")
+        NSLog("[ComposerPianoImpl]   - AID: \(self.aid ?? "(not set)")")
+        NSLog("[ComposerPianoImpl]   - Tags count: \(self.tags.count)")
+        NSLog("[ComposerPianoImpl]   - Tags: [\(self.tags.joined(separator: ", "))]")
+        NSLog("[ComposerPianoImpl]   - Tags detail: \(self.tags)")
+        NSLog("[ComposerPianoImpl]   - Zone ID: \(self.zoneId ?? "(not set)")")
+        NSLog("[ComposerPianoImpl]   - Referrer: \(self.referrer ?? "(not set)")")
+        NSLog("[ComposerPianoImpl]   - URL: \(self.url ?? "(not set)")")
+        NSLog("[ComposerPianoImpl]   - User Token: \(self.userToken != nil ? "Set" : "Not set")")
+        NSLog("[ComposerPianoImpl]   - Custom Variables: \(self.customVariables)")
 
         self.experienceResolver = resolver
         self.experienceRejecter = rejecter
@@ -203,7 +226,7 @@ import React
         DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) { [weak self] in
             // Check if the promise hasn't been resolved yet
             if self?.experienceResolver != nil {
-                print("[ComposerPianoImpl] WARNING: No events received within timeout period (5 seconds)")
+                NSLog("[ComposerPianoImpl] WARNING: No events received within timeout period (5 seconds)")
                 let timeoutResult = [
                     "eventType": "noEvents",
                     "message": "No events received within timeout period"
@@ -214,6 +237,13 @@ import React
             }
         }
 
+        NSLog("")
+        NSLog("[ComposerPianoImpl] >>> BUILDING EXPERIENCE REQUEST <<<")
+        NSLog("[ComposerPianoImpl] >>> Tags being passed to composer: [\(self.tags.joined(separator: ", "))]")
+        NSLog("[ComposerPianoImpl] >>> Tags count: \(self.tags.count)")
+        NSLog("[ComposerPianoImpl] >>> ⚠️  IF TAGS APPEAR HERE AFTER clearTags(), THE BUG IS IN THE WRAPPER")
+        NSLog("[ComposerPianoImpl] >>> ⚠️  IF TAGS APPEAR IN PIANO REQUEST BUT NOT HERE, THE BUG IS IN PIANO SDK")
+
         _ =
             composer
             .tags(self.tags)
@@ -221,19 +251,25 @@ import React
             .referrer(self.referrer ?? "")
             .url(self.url ?? "")
 
+        NSLog("[ComposerPianoImpl] ⚠️  NOTE: PianoComposer SDK does NOT provide getters to verify internal state")
+        NSLog("[ComposerPianoImpl] ⚠️  We can only verify OUR wrapper state, not Piano's singleton state")
+        NSLog("[ComposerPianoImpl] ⚠️  If bug exists, it's in Piano SDK's internal tag management")
+
         if !self.customVariables.isEmpty {
-            print("[ComposerPianoImpl] Applying \(self.customVariables.count) custom variables...")
+            NSLog("[ComposerPianoImpl] Applying \(self.customVariables.count) custom variables...")
             for (key, value) in self.customVariables {
-                print("[ComposerPianoImpl]   - Applying custom variable: '\(key)' = '\(value)'")
+                NSLog("[ComposerPianoImpl]   - Applying custom variable: '\(key)' = '\(value)'")
                 _ = composer.customVariable(name: key, value: value)
             }
-            print("[ComposerPianoImpl] Custom variables applied successfully.")
+            NSLog("[ComposerPianoImpl] Custom variables applied successfully.")
         } else {
-            print("[ComposerPianoImpl] No custom variables to apply.")
+            NSLog("[ComposerPianoImpl] No custom variables to apply.")
         }
 
-        print("[ComposerPianoImpl] Calling composer.execute()")
+        NSLog("[ComposerPianoImpl] ✓ Experience request configured")
+        NSLog(String(repeating: "=", count: 80))
+        NSLog("[ComposerPianoImpl] Calling composer.execute()")
         composer.execute()
-        print("[ComposerPianoImpl] composer.execute() called - waiting for events...")
+        NSLog("[ComposerPianoImpl] composer.execute() called - collecting events for 2 seconds...")
     }
 }

package/ios/MyComposerDelegate.swift

@@ -20,9 +20,10 @@ import React
     // MARK: - Promise Handling Helpers
 
     private func collectEvent(eventData: [String: Any]) {
-        print("[MyComposerDelegate] Event collected: \(eventData)")
+        NSLog("[MyComposerDelegate] Event collected: \(eventData)")
         collectedEvents.append(eventData)
-        print("[MyComposerDelegate] Total events collected so far: \(collectedEvents.count)")
+        NSLog("[MyComposerDelegate] Total events collected so far: \(collectedEvents.count)")
+        NSLog("[MyComposerDelegate] Event added to collection (\(collectedEvents.count) total)")
 
         // If this is the first event, start the collection timeout
         if collectedEvents.count == 1 {
@@ -31,13 +32,13 @@ import React
     }
 
     private func startEventCollectionTimeout() {
-        print("[MyComposerDelegate] Starting event collection timeout (2 seconds)...")
+        NSLog("[MyComposerDelegate] Starting event collection timeout (2 seconds)...")
 
         // Cancel any existing timeout
         timeoutWorkItem?.cancel()
 
         let workItem = DispatchWorkItem { [weak self] in
-            print("[MyComposerDelegate] Event collection timeout reached - resolving with \(self?.collectedEvents.count ?? 0) events")
+            NSLog("[MyComposerDelegate] Event collection timeout reached - resolving with \(self?.collectedEvents.count ?? 0) events")
             self?.resolveWithCollectedEvents()
         }
 
@@ -46,37 +47,44 @@ import React
     }
 
     private func resolveWithCollectedEvents() {
-        guard !promiseResolved else { return }
+        guard !promiseResolved else {
+            NSLog("[MyComposerDelegate] Promise already resolved - skipping")
+            return
+        }
         promiseResolved = true
 
-        guard let resolver = self.impl?.experienceResolver else { return }
+        guard let resolver = self.impl?.experienceResolver else {
+            NSLog("[MyComposerDelegate] No resolver available")
+            return
+        }
 
         let result: [String: Any]
 
         switch collectedEvents.count {
         case 0:
-            print("[MyComposerDelegate] No events collected - returning noEvents result")
+            NSLog("[MyComposerDelegate] No events collected - returning noEvents result")
             result = [
                 "eventType": "noEvents",
                 "message": "No events received"
             ]
         case 1:
-            print("[MyComposerDelegate] Single event collected - returning event directly")
+            NSLog("[MyComposerDelegate] Single event collected - returning event directly")
             result = collectedEvents[0]
         default:
-            print("[MyComposerDelegate] Multiple events collected - returning as array")
+            NSLog("[MyComposerDelegate] Multiple events collected - returning as array")
             result = [
                 "eventType": "multipleEvents",
                 "events": collectedEvents
             ]
         }
 
+        NSLog("[MyComposerDelegate] Resolving promise with result type: \(result["eventType"] ?? "unknown")")
         resolver(result)
         clearPromiseHandlers()
     }
 
     public func initializeEventCollection() {
-        print("[MyComposerDelegate] Initializing event collection system")
+        NSLog("[MyComposerDelegate] Initializing event collection system")
         collectedEvents.removeAll()
         promiseResolved = false
         timeoutWorkItem?.cancel()
@@ -84,7 +92,11 @@ import React
     }
 
     private func rejectPromise(with error: Error) {
-        guard let rejecter = self.impl?.experienceRejecter else { return }
+        NSLog("[MyComposerDelegate] Rejecting promise with error: \(error.localizedDescription)")
+        guard let rejecter = self.impl?.experienceRejecter else {
+            NSLog("[MyComposerDelegate] No rejecter available")
+            return
+        }
         let errorCode = "EXECUTION_FAILED"
         let errorMessage = error.localizedDescription
         rejecter(errorCode, errorMessage, error)
@@ -92,6 +104,7 @@ import React
     }
 
     private func clearPromiseHandlers() {
+        NSLog("[MyComposerDelegate] Clearing promise handlers and event collection")
         timeoutWorkItem?.cancel()
         timeoutWorkItem = nil
         collectedEvents.removeAll()
@@ -105,83 +118,85 @@ import React
     public func showLogin(
         composer: PianoComposer, event: XpEvent, params: ShowLoginEventParams?
     ) {
-        print("[MyComposerDelegate] === SHOW LOGIN EVENT RECEIVED ===")
+        NSLog("[MyComposerDelegate] === SHOW LOGIN EVENT RECEIVED ===")
         var eventData = paramsToDictionary(params)
         eventData["eventType"] = "showLogin"
-        print("[MyComposerDelegate] Event data: \(eventData)")
+        NSLog("[MyComposerDelegate] Event data: \(eventData)")
         collectEvent(eventData: eventData)
     }
 
     public func showTemplate(
         composer: PianoComposer, event: XpEvent, params: ShowTemplateEventParams?
     ) {
-        print("[MyComposerDelegate] === SHOW TEMPLATE EVENT RECEIVED ===")
+        NSLog("[MyComposerDelegate] === SHOW TEMPLATE EVENT RECEIVED ===")
         var eventData = paramsToDictionary(params)
         eventData["eventType"] = "showTemplate"
-        print("[MyComposerDelegate] Event data: \(eventData)")
+        NSLog("[MyComposerDelegate] Event data: \(eventData)")
         collectEvent(eventData: eventData)
     }
 
     public func showForm(
         composer: PianoComposer, event: XpEvent, params: ShowFormEventParams?
     ) {
-        print("[MyComposerDelegate] === SHOW FORM EVENT RECEIVED ===")
+        NSLog("[MyComposerDelegate] === SHOW FORM EVENT RECEIVED ===")
         var eventData = paramsToDictionary(params)
         eventData["eventType"] = "showForm"
-        print("[MyComposerDelegate] Event data: \(eventData)")
+        NSLog("[MyComposerDelegate] Event data: \(eventData)")
         collectEvent(eventData: eventData)
     }
 
     public func showRecommendations(
         composer: PianoComposer, event: XpEvent, params: ShowRecommendationsEventParams?
     ) {
-        print("[MyComposerDelegate] === SHOW RECOMMENDATIONS EVENT RECEIVED ===")
+        NSLog("[MyComposerDelegate] === SHOW RECOMMENDATIONS EVENT RECEIVED ===")
         var eventData = paramsToDictionary(params)
         eventData["eventType"] = "showRecommendations"
-        print("[MyComposerDelegate] Event data: \(eventData)")
+        NSLog("[MyComposerDelegate] Event data: \(eventData)")
         collectEvent(eventData: eventData)
     }
 
     public func nonSite(composer: PianoComposer, event: XpEvent) {
-        print("[MyComposerDelegate] === NON SITE EVENT RECEIVED ===")
+        NSLog("[MyComposerDelegate] === NON SITE EVENT RECEIVED ===")
         let eventData = [
             "eventType": "nonSite"
         ] as [String : Any]
-        print("[MyComposerDelegate] Event data: \(eventData)")
+        NSLog("[MyComposerDelegate] Event data: \(eventData)")
         collectEvent(eventData: eventData)
     }
 
     public func setResponseVariable(
         composer: PianoComposer, event: XpEvent, params: SetResponseVariableParams?
     ) {
-        print("[MyComposerDelegate] === SET RESPONSE VARIABLE EVENT RECEIVED ===")
+        NSLog("[MyComposerDelegate] === SET RESPONSE VARIABLE EVENT RECEIVED ===")
         var eventData = paramsToDictionary(params)
         eventData["eventType"] = "setResponseVariable"
-        print("[MyComposerDelegate] Event data: \(eventData)")
+        NSLog("[MyComposerDelegate] Event data: \(eventData)")
         collectEvent(eventData: eventData)
     }
 
     public func meterActive(
         composer: PianoComposer, event: XpEvent, params: PageViewMeterEventParams?
     ) {
-        print("[MyComposerDelegate] === METER ACTIVE EVENT RECEIVED ===")
-        print("[MyComposerDelegate] Meter name: \(params?.meterName ?? "N/A")")
+        NSLog("[MyComposerDelegate] === METER ACTIVE EVENT RECEIVED ===")
+        NSLog("[MyComposerDelegate] Meter name: \(params?.meterName ?? "N/A")")
+        NSLog("[MyComposerDelegate] Event params: \(params != nil ? String(describing: params!) : "nil")")
         var eventData = paramsToDictionary(params)
         eventData["eventType"] = "meter"
         eventData["meterState"] = "active"  // Add state to differentiate from expired
-        print("[MyComposerDelegate] Event data: \(eventData)")
+        NSLog("[MyComposerDelegate] Event data: \(eventData)")
         collectEvent(eventData: eventData)
     }
 
     public func meterExpired(
         composer: PianoComposer, event: XpEvent, params: PageViewMeterEventParams?
     ) {
-        print("[MyComposerDelegate] === METER EXPIRED EVENT RECEIVED ===")
-        print("[MyComposerDelegate] Meter name: \(params?.meterName ?? "N/A")")
+        NSLog("[MyComposerDelegate] === METER EXPIRED EVENT RECEIVED ===")
+        NSLog("[MyComposerDelegate] Meter name: \(params?.meterName ?? "N/A")")
+        NSLog("[MyComposerDelegate] Event params: \(params != nil ? String(describing: params!) : "nil")")
         var eventData = paramsToDictionary(params)
         eventData["eventType"] = "meter"
         eventData["meterState"] = "expired"  // Add state to differentiate from active
-        print("[MyComposerDelegate] Event data: \(eventData)")
+        NSLog("[MyComposerDelegate] Event data: \(eventData)")
         collectEvent(eventData: eventData)
     }
 
@@ -189,12 +204,12 @@ import React
      * Called when the user segment is true.
      */
     public func userSegmentTrue(composer: PianoComposer, event: XpEvent) {
-        print("[MyComposerDelegate] === USER SEGMENT TRUE EVENT RECEIVED ===")
+        NSLog("[MyComposerDelegate] === USER SEGMENT TRUE EVENT RECEIVED ===")
         let eventData = [
             "eventType": "userSegment",
             "state": true
         ] as [String : Any]
-        print("[MyComposerDelegate] Event data: \(eventData)")
+        NSLog("[MyComposerDelegate] Event data: \(eventData)")
         collectEvent(eventData: eventData)
     }
 
@@ -202,12 +217,12 @@ import React
      * Called when the user segment is false.
      */
     public func userSegmentFalse(composer: PianoComposer, event: XpEvent) {
-        print("[MyComposerDelegate] === USER SEGMENT FALSE EVENT RECEIVED ===")
+        NSLog("[MyComposerDelegate] === USER SEGMENT FALSE EVENT RECEIVED ===")
         let eventData = [
             "eventType": "userSegment",
             "state": false
         ] as [String : Any]
-        print("[MyComposerDelegate] Event data: \(eventData)")
+        NSLog("[MyComposerDelegate] Event data: \(eventData)")
         collectEvent(eventData: eventData)
     }
 
@@ -217,10 +232,10 @@ import React
     public func experienceExecute(
         composer: PianoComposer, event: XpEvent, params: ExperienceExecuteEventParams?
     ) {
-        print("[MyComposerDelegate] === EXPERIENCE EXECUTE EVENT RECEIVED ===")
+        NSLog("[MyComposerDelegate] === EXPERIENCE EXECUTE EVENT RECEIVED ===")
         var eventData = paramsToDictionary(params)
         eventData["eventType"] = "experienceExecute"
-        print("[MyComposerDelegate] Event data: \(eventData)")
+        NSLog("[MyComposerDelegate] Event data: \(eventData)")
         collectEvent(eventData: eventData)
     }
 
@@ -230,9 +245,10 @@ import React
     public func experienceExecutionFailed(
         composer: PianoComposer, event: XpEvent, params: FailureEventParams?
     ) {
-        print("[MyComposerDelegate] === EXPERIENCE EXECUTION FAILED EVENT ===")
+        NSLog("[MyComposerDelegate] === EXPERIENCE EXECUTION FAILED EVENT ===")
         let eventData = paramsToDictionary(params)
-        print("[MyComposerDelegate] Failure details: \(eventData)")
+        NSLog("[MyComposerDelegate] Failure details: \(eventData)")
+        NSLog("[MyComposerDelegate] Experience execution failed - rejecting promise")
         let error = NSError(
             domain: "PianoSDK",
             code: -1,
@@ -246,8 +262,9 @@ import React
      * This is a lifecycle callback that indicates Piano has finished processing.
      */
     public func composerExecutionCompleted(composer: PianoComposer) {
-        print("[MyComposerDelegate] === COMPOSER EXECUTION COMPLETED ===")
-        print("[MyComposerDelegate] Piano composer has finished execution")
+        NSLog("[MyComposerDelegate] === COMPOSER EXECUTION COMPLETED ===")
+        NSLog("[MyComposerDelegate] Piano composer has finished execution")
+        NSLog("[MyComposerDelegate] Total events collected: \(collectedEvents.count)")
         // Note: This is just a lifecycle notification, we don't send it as an event
         // The actual events have already been collected and will be sent via the timeout
     }

package/ios/SdkPianoio.swift

@@ -22,27 +22,27 @@ class SdkPianoio: NSObject {
         aid: String, isSandbox: Bool, resolver: @escaping RCTPromiseResolveBlock,
         rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] initialize called with AID: \(aid), isSandbox: \(isSandbox)")
+        NSLog("[\(Self.TAG)] initialize called with AID: \(aid), isSandbox: \(isSandbox)")
 
         do {
             guard !aid.isEmpty else {
-                print("[\(Self.TAG)] Initialization failed: AID cannot be empty")
+                NSLog("[\(Self.TAG)] Initialization failed: AID cannot be empty")
                 rejecter("INIT_ERROR", "AID cannot be empty", nil)
                 return
             }
 
             if isInitialized {
-                print("[\(Self.TAG)] Already initialized.")
+                NSLog("[\(Self.TAG)] Already initialized.")
                 resolver(true)
                 return
             }
 
             try moduleImpl.initialize(aid: aid, isSandbox: isSandbox)
             isInitialized = true
-            print("[\(Self.TAG)] Initialization successful.")
+            NSLog("[\(Self.TAG)] Initialization successful.")
             resolver(true)
         } catch {
-            print("[\(Self.TAG)] Initialization failed: \(error.localizedDescription)")
+            NSLog("[\(Self.TAG)] Initialization failed: \(error.localizedDescription)")
             rejecter("INIT_ERROR", "Failed to initialize Piano SDK: \(error.localizedDescription)", error)
         }
     }
@@ -54,7 +54,7 @@ class SdkPianoio: NSObject {
         tag: String, resolver: @escaping RCTPromiseResolveBlock,
         rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] addTag called with: \(tag)")
+        NSLog("[\(Self.TAG)] addTag called with: '\(tag)'")
 
         guard validateInitialization(rejecter: rejecter),
               validateParameter(tag, paramName: "tag", rejecter: rejecter) else {
@@ -62,6 +62,7 @@ class SdkPianoio: NSObject {
         }
 
         moduleImpl.addTag(tag)
+        NSLog("[\(Self.TAG)] addTag completed successfully")
         resolver(true)
     }
 
@@ -70,7 +71,7 @@ class SdkPianoio: NSObject {
         tags: [String], resolver: @escaping RCTPromiseResolveBlock,
         rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] addTags called")
+        NSLog("[\(Self.TAG)] addTags called with \(tags.count) tags: [\(tags.joined(separator: ", "))]")
 
         guard validateInitialization(rejecter: rejecter),
               validateArray(tags, paramName: "tags", rejecter: rejecter) else {
@@ -78,6 +79,7 @@ class SdkPianoio: NSObject {
         }
 
         moduleImpl.addTags(tags)
+        NSLog("[\(Self.TAG)] addTags completed successfully")
         resolver(true)
     }
 
@@ -86,7 +88,7 @@ class SdkPianoio: NSObject {
         zoneId: String, resolver: @escaping RCTPromiseResolveBlock,
         rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] setZoneId called with: \(zoneId)")
+        NSLog("[\(Self.TAG)] setZoneId called with: \(zoneId)")
 
         guard validateInitialization(rejecter: rejecter) else {
             return
@@ -101,7 +103,7 @@ class SdkPianoio: NSObject {
         referrer: String, resolver: @escaping RCTPromiseResolveBlock,
         rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] setReferrer called with: \(referrer)")
+        NSLog("[\(Self.TAG)] setReferrer called with: \(referrer)")
 
         guard validateInitialization(rejecter: rejecter) else {
             return
@@ -116,7 +118,7 @@ class SdkPianoio: NSObject {
         url: String, resolver: @escaping RCTPromiseResolveBlock,
         rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] setUrl called with: \(url)")
+        NSLog("[\(Self.TAG)] setUrl called with: \(url)")
 
         guard validateInitialization(rejecter: rejecter) else {
             return
@@ -131,7 +133,7 @@ class SdkPianoio: NSObject {
         token: String, resolver: @escaping RCTPromiseResolveBlock,
         rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] setUserToken called")
+        NSLog("[\(Self.TAG)] setUserToken called")
 
         guard validateInitialization(rejecter: rejecter) else {
             return
@@ -146,7 +148,7 @@ class SdkPianoio: NSObject {
         name: String, value: String, resolver: @escaping RCTPromiseResolveBlock,
         rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] addCustomVariable called with: \(name) = \(value)")
+        NSLog("[\(Self.TAG)] addCustomVariable called with: \(name) = \(value)")
 
         guard validateInitialization(rejecter: rejecter),
               validateParameter(name, paramName: "name", rejecter: rejecter),
@@ -163,7 +165,7 @@ class SdkPianoio: NSObject {
         variables: [String: String], resolver: @escaping RCTPromiseResolveBlock,
         rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] setCustomVariables called")
+        NSLog("[\(Self.TAG)] setCustomVariables called")
 
         guard validateInitialization(rejecter: rejecter),
               validateDictionary(variables, paramName: "variables", rejecter: rejecter) else {
@@ -188,12 +190,14 @@ class SdkPianoio: NSObject {
     func executeExperience(
         resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] executeExperience called")
+        NSLog("[\(Self.TAG)] executeExperience called")
 
         guard validateInitialization(rejecter: rejecter) else {
+            NSLog("[\(Self.TAG)] executeExperience failed: SDK not initialized")
             return
         }
 
+        NSLog("[\(Self.TAG)] Delegating to moduleImpl.executeExperience()")
         moduleImpl.executeExperience(resolver: resolver, rejecter: rejecter)
     }
 
@@ -203,7 +207,7 @@ class SdkPianoio: NSObject {
     func signIn(
         resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] signIn called")
+        NSLog("[\(Self.TAG)] signIn called")
 
         guard validateInitialization(rejecter: rejecter) else {
             return
@@ -221,7 +225,7 @@ class SdkPianoio: NSObject {
     func signOut(
         resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] signOut called")
+        NSLog("[\(Self.TAG)] signOut called")
 
         guard validateInitialization(rejecter: rejecter) else {
             return
@@ -239,7 +243,7 @@ class SdkPianoio: NSObject {
     func getCurrentUser(
         resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] getCurrentUser called")
+        NSLog("[\(Self.TAG)] getCurrentUser called")
 
         guard validateInitialization(rejecter: rejecter) else {
             return
@@ -272,7 +276,7 @@ class SdkPianoio: NSObject {
     func isAuthenticated(
         resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] isAuthenticated called")
+        NSLog("[\(Self.TAG)] isAuthenticated called")
 
         guard validateInitialization(rejecter: rejecter) else {
             return
@@ -293,21 +297,23 @@ class SdkPianoio: NSObject {
     func getStatus(
         resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] getStatus called")
+        NSLog("[\(Self.TAG)] getStatus called")
 
         guard validateInitialization(rejecter: rejecter) else {
             return
         }
 
+        let tags = moduleImpl.getTags()
         let statusMap: [String: Any] = [
             "initialized": isInitialized,
             "aid": moduleImpl.getAid(),
-            "tags": moduleImpl.getTags(),
+            "tags": tags,
             "zoneId": moduleImpl.getZoneId(),
             "referrer": moduleImpl.getReferrer(),
             "url": moduleImpl.getUrl(),
             "customVariables": moduleImpl.getCustomVariables()
         ]
+        NSLog("[\(Self.TAG)] Status retrieved - Tags count: \(tags.count), Tags: [\(tags.joined(separator: ", "))]")
         resolver(statusMap)
     }
 
@@ -315,7 +321,7 @@ class SdkPianoio: NSObject {
     func isInitialized(
         resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] isInitialized called")
+        NSLog("[\(Self.TAG)] isInitialized called")
         resolver(isInitialized)
     }
 
@@ -324,7 +330,7 @@ class SdkPianoio: NSObject {
         tag: String, resolver: @escaping RCTPromiseResolveBlock,
         rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] removeTag called with: \(tag)")
+        NSLog("[\(Self.TAG)] removeTag called with: \(tag)")
 
         guard validateInitialization(rejecter: rejecter),
               validateParameter(tag, paramName: "tag", rejecter: rejecter) else {
@@ -340,7 +346,7 @@ class SdkPianoio: NSObject {
         key: String, resolver: @escaping RCTPromiseResolveBlock,
         rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] removeCustomVariable called with: \(key)")
+        NSLog("[\(Self.TAG)] removeCustomVariable called with: \(key)")
 
         guard validateInitialization(rejecter: rejecter),
               validateParameter(key, paramName: "key", rejecter: rejecter) else {
@@ -355,13 +361,14 @@ class SdkPianoio: NSObject {
     func clearTags(
         resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] clearTags called")
+        NSLog("[\(Self.TAG)] clearTags called")
 
         guard validateInitialization(rejecter: rejecter) else {
             return
         }
 
         moduleImpl.clearTags()
+        NSLog("[\(Self.TAG)] clearTags completed successfully")
         resolver(true)
     }
 
@@ -369,7 +376,7 @@ class SdkPianoio: NSObject {
     func clearCustomVariables(
         resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] clearCustomVariables called")
+        NSLog("[\(Self.TAG)] clearCustomVariables called")
 
         guard validateInitialization(rejecter: rejecter) else {
             return
@@ -383,7 +390,7 @@ class SdkPianoio: NSObject {
     func clearConfiguration(
         resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock
     ) {
-        print("[\(Self.TAG)] clearConfiguration called")
+        NSLog("[\(Self.TAG)] clearConfiguration called")
 
         guard validateInitialization(rejecter: rejecter) else {
             return
@@ -399,7 +406,7 @@ class SdkPianoio: NSObject {
         rejecter: RCTPromiseRejectBlock
     ) -> Bool {
         guard isInitialized else {
-            print("[\(Self.TAG)] Validation failed: SDK not initialized.")
+            NSLog("[\(Self.TAG)] Validation failed: SDK not initialized.")
             rejecter("NOT_INITIALIZED", "Piano SDK not initialized. Call initialize() first.", nil)
             return false
         }
@@ -410,7 +417,7 @@ class SdkPianoio: NSObject {
         _ value: String?, paramName: String, rejecter: RCTPromiseRejectBlock
     ) -> Bool {
         guard let value = value, !value.isEmpty else {
-            print("[\(Self.TAG)] Validation failed: Parameter '\(paramName)' is null or empty.")
+            NSLog("[\(Self.TAG)] Validation failed: Parameter '\(paramName)' is null or empty.")
             rejecter("INVALID_PARAMETER", "Parameter '\(paramName)' cannot be empty", nil)
             return false
         }
@@ -421,7 +428,7 @@ class SdkPianoio: NSObject {
         _ array: [T]?, paramName: String, rejecter: RCTPromiseRejectBlock
     ) -> Bool {
         guard let array = array, !array.isEmpty else {
-            print("[\(Self.TAG)] Validation failed: Array '\(paramName)' is null or empty.")
+            NSLog("[\(Self.TAG)] Validation failed: Array '\(paramName)' is null or empty.")
             rejecter("INVALID_PARAMETER", "Array '\(paramName)' cannot be empty", nil)
             return false
         }
@@ -432,7 +439,7 @@ class SdkPianoio: NSObject {
         _ dict: [K: V]?, paramName: String, rejecter: RCTPromiseRejectBlock
     ) -> Bool {
         guard let dict = dict else {
-            print("[\(Self.TAG)] Validation failed: Dictionary '\(paramName)' is null.")
+            NSLog("[\(Self.TAG)] Validation failed: Dictionary '\(paramName)' is null.")
             rejecter("INVALID_PARAMETER", "Dictionary '\(paramName)' cannot be null", nil)
             return false
         }

package/ios/TokenService.swift

@@ -42,17 +42,21 @@ public class TokenService: NSObject, PianoIDDelegate {
 
     public func initialize(aid: String, isSandbox: Bool = false) {
         if isInitialized {
+            NSLog("[TokenService] Already initialized - skipping")
             return
         }
-        print("TokenService: Initializing with AID: \(aid), isSandbox: \(isSandbox)")
+        NSLog("[TokenService] Initializing with AID: \(aid), isSandbox: \(isSandbox)")
 
         PianoID.shared.aid = aid
         PianoID.shared.endpoint = isSandbox ? PianoEndpoint.sandbox : PianoEndpoint.production
         PianoID.shared.delegate = self
 
-        print("TokenService: Using endpoint: \(PianoID.shared.endpoint)")
+        NSLog("[TokenService] PianoID configured:")
+        NSLog("[TokenService]   - AID: \(aid)")
+        NSLog("[TokenService]   - Endpoint: \(PianoID.shared.endpoint)")
+        NSLog("[TokenService]   - Delegate: Set")
         isInitialized = true
-        print("TokenService: Initialization completed successfully")
+        NSLog("[TokenService] Initialization completed successfully")
     }
 
     // MARK: - Authentication Methods
@@ -61,32 +65,36 @@ public class TokenService: NSObject, PianoIDDelegate {
 
     public func signIn(resolver: @escaping (Any?) -> Void, rejecter: @escaping (String?, String?, Error?) -> Void) {
         if !isInitialized {
-            print("TokenService: Not initialized. Call initialize() first.")
+            NSLog("[TokenService] ERROR: Not initialized. Call initialize() first.")
             rejecter("INIT_ERROR", "TokenService not initialized", nil)
             return
         }
-        print("TokenService: Starting sign in")
+        NSLog("[TokenService] Starting sign in flow")
+        NSLog("[TokenService] Setting up promise handlers")
         self.signInResolver = resolver
         self.signInRejecter = rejecter
+        NSLog("[TokenService] Calling PianoID.shared.signIn()")
         PianoID.shared.signIn()
     }
 
 
     public func signOut(resolver: @escaping (Any?) -> Void, rejecter: @escaping (String?, String?, Error?) -> Void) {
         if !isInitialized {
-            print("TokenService: Not initialized.")
+            NSLog("[TokenService] ERROR: Not initialized.")
             rejecter("INIT_ERROR", "TokenService not initialized", nil)
             return
         }
         guard let token = self.cachedToken else {
-            print("TokenService: No user is signed in.")
+            NSLog("[TokenService] No user is signed in - already signed out")
             resolver(["success": true]) // Already signed out
             return
         }
 
-        print("TokenService: Starting sign out")
+        NSLog("[TokenService] Starting sign out flow")
+        NSLog("[TokenService] Current token: \(token.accessToken.prefix(20))...")
         self.signOutResolver = resolver
         self.signOutRejecter = rejecter
+        NSLog("[TokenService] Calling PianoID.shared.signOut()")
         PianoID.shared.signOut(token: token.accessToken)
     }
 
@@ -94,9 +102,11 @@ public class TokenService: NSObject, PianoIDDelegate {
 
     public func getCurrentUser() -> User? {
         guard let token = self.cachedToken else {
+            NSLog("[TokenService] getCurrentUser: No cached token available")
             return nil
         }
 
+        NSLog("[TokenService] getCurrentUser: Decoding JWT token")
         // Decode the JWT to get the claims
         let claims = decode(jwtToken: token.accessToken)
 
@@ -106,7 +116,7 @@ public class TokenService: NSObject, PianoIDDelegate {
         let userId = claims?["sub"] as? String ?? "unknown"
         let email = claims?["email"] as? String ?? "unknown"
 
-        print("[TokenService] Extracted user - ID: \(userId), Email: \(email)")
+        NSLog("[TokenService] Extracted user - ID: \(userId), Email: \(email)")
 
         return User(
             id: userId,
@@ -116,17 +126,20 @@ public class TokenService: NSObject, PianoIDDelegate {
     }
 
     public func isAuthenticated() -> Bool {
-        return self.cachedToken != nil
+        let isAuth = self.cachedToken != nil
+        NSLog("[TokenService] isAuthenticated: \(isAuth)")
+        return isAuth
     }
 
     // MARK: - PianoIDDelegate Implementation
 
     public func signIn(result: PianoIDSignInResult!, withError error: Error!) {
         if let r = result {
-            print("TokenService: Sign in successful")
+            NSLog("[TokenService] === SIGN IN SUCCESSFUL ===")
+            NSLog("[TokenService] Caching token")
             self.cachedToken = r.token
             let user = self.getCurrentUser()
-            
+
             let resultMap: [String: Any] = [
                 "success": true,
                 "uid": user?.id ?? "",
@@ -134,34 +147,42 @@ public class TokenService: NSObject, PianoIDDelegate {
                 "accessToken": user?.accessToken ?? "",
                 "authenticated": true
             ]
+            NSLog("[TokenService] Resolving sign in promise with user: \(user?.email ?? "unknown")")
             self.signInResolver?(resultMap)
         } else if let e = error {
-            print("TokenService: Sign in failed: \(e.localizedDescription)")
+            NSLog("[TokenService] === SIGN IN FAILED ===")
+            NSLog("[TokenService] Error: \(e.localizedDescription)")
             self.signInRejecter?("SIGNIN_ERROR", e.localizedDescription, e)
         }
 
+        NSLog("[TokenService] Cleaning up sign in promise handlers")
         self.signInResolver = nil
         self.signInRejecter = nil
     }
 
     public func signOut(withError error: Error!) {
         if let e = error {
-            print("TokenService: Sign out failed: \(e.localizedDescription)")
+            NSLog("[TokenService] === SIGN OUT FAILED ===")
+            NSLog("[TokenService] Error: \(e.localizedDescription)")
             self.signOutRejecter?("SIGNOUT_ERROR", e.localizedDescription, e)
         } else {
-            print("TokenService: Sign out successful")
+            NSLog("[TokenService] === SIGN OUT SUCCESSFUL ===")
+            NSLog("[TokenService] Clearing cached token")
             self.cachedToken = nil
             self.signOutResolver?(["success": true])
         }
+        NSLog("[TokenService] Cleaning up sign out promise handlers")
         // Clean up promises
         self.signOutResolver = nil
         self.signOutRejecter = nil
     }
 
     public func cancel() {
-        print("TokenService: User cancelled the flow")
+        NSLog("[TokenService] === USER CANCELLED ===")
+        NSLog("[TokenService] User cancelled the authentication flow")
         // If there's an active sign-in promise, reject it.
         if let rejecter = self.signInRejecter {
+            NSLog("[TokenService] Rejecting sign in promise due to cancellation")
             rejecter("CANCELLED", "User cancelled the sign-in process.", nil)
             self.signInResolver = nil
             self.signInRejecter = nil
@@ -171,25 +192,29 @@ public class TokenService: NSObject, PianoIDDelegate {
     // MARK: - Helper Methods
     
     private func decode(jwtToken jwt: String) -> [String: Any]? {
+        NSLog("[TokenService] [decode] Decoding JWT token")
         let segments = jwt.components(separatedBy: ".")
         guard segments.count > 1 else {
-            print("JWT Error: Invalid token format")
+            NSLog("[TokenService] [decode] ERROR: Invalid token format - expected 3 segments, got \(segments.count)")
             return nil
         }
-        
+
+        NSLog("[TokenService] [decode] Token has \(segments.count) segments")
         var base64String = segments[1]
         let requiredLength = Int(4 * ceil(Float(base64String.count) / 4.0))
         let nbrPaddings = requiredLength - base64String.count
         if nbrPaddings > 0 {
+            NSLog("[TokenService] [decode] Adding \(nbrPaddings) padding characters")
             let padding = String(repeating: "=", count: nbrPaddings)
             base64String = base64String.appending(padding)
         }
-        
+
         guard let data = Data(base64Encoded: base64String, options: .ignoreUnknownCharacters) else {
-            print("JWT Error: Could not decode base64 payload")
+            NSLog("[TokenService] [decode] ERROR: Could not decode base64 payload")
             return nil
         }
-        
+
+        NSLog("[TokenService] [decode] Successfully decoded JWT payload")
         return try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-sdk-pianoio",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "Piano io sdk integration",
   "source": "./src/index.tsx",
   "main": "./lib/commonjs/index.js",