@wayq/beekon-rn 0.0.8 → 0.1.0

package/android/src/main/java/in/wayq/beekonrn/BeekonRnModule.kt

@@ -25,8 +25,11 @@ import `in`.wayq.beekon.Location
 import `in`.wayq.beekon.LocationQuality
 import `in`.wayq.beekon.LocationTrigger
 import `in`.wayq.beekon.LocationUnavailableReason
+import `in`.wayq.beekon.LogEntry
+import `in`.wayq.beekon.LogLevel
 import `in`.wayq.beekon.MotionState
 import `in`.wayq.beekon.NotificationConfig
+import `in`.wayq.beekon.PermissionStatus
 import `in`.wayq.beekon.StationaryMode
 import `in`.wayq.beekon.StopReason
 import `in`.wayq.beekon.SyncConfig
@@ -64,6 +67,7 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     scope.launch { Beekon.syncStatus.collect { emitOnSyncStatus(syncStatusToWire(it)) } }
     scope.launch { Beekon.authChanges.collect { emitOnAuthTokens(tokenRefreshToWire(it)) } }
     scope.launch { Beekon.licenseStatus.collect { emitOnLicenseStatus(licenseStatusToWire(it)) } }
+    scope.launch { Beekon.logs.collect { emitOnLog(logEntryToWire(it)) } }
   }
 
   // ---------------------------------------------------------------------------
@@ -232,6 +236,60 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     promise.resolve(licenseStatusToWire(Beekon.licenseStatus.value))
   }
 
+  override fun getPermissionStatus(promise: Promise) {
+    // Synchronous, non-throwing read on the native SDK.
+    promise.resolve(permissionStatusToWire(Beekon.getPermissionStatus()))
+  }
+
+  // ---------------------------------------------------------------------------
+  // Diagnostic logs (spec diagnostics/log-format-v1)
+  // ---------------------------------------------------------------------------
+
+  override fun getLog(fromMs: Double, toMs: Double, promise: Promise) {
+    scope.launch {
+      try {
+        val from = Instant.ofEpochMilli(fromMs.toLong())
+        val to = Instant.ofEpochMilli(toMs.toLong())
+        val arr: WritableArray = Arguments.createArray()
+        for (e in Beekon.getLog(from, to)) arr.pushMap(logEntryToWire(e))
+        promise.resolve(arr)
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "getLog failed", t)
+      }
+    }
+  }
+
+  override fun exportLog(promise: Promise) {
+    scope.launch {
+      try {
+        promise.resolve(Beekon.exportLog())
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "exportLog failed", t)
+      }
+    }
+  }
+
+  override fun clearLog(promise: Promise) {
+    scope.launch {
+      try {
+        Beekon.clearLog()
+        promise.resolve(null)
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "clearLog failed", t)
+      }
+    }
+  }
+
+  override fun setLogLevel(level: String, promise: Promise) {
+    Beekon.setLogLevel(toLogLevel(level))
+    promise.resolve(null)
+  }
+
+  override fun log(level: String, message: String, promise: Promise) {
+    Beekon.log(toLogLevel(level), message)
+    promise.resolve(null)
+  }
+
   override fun invalidate() {
     super.invalidate()
     scope.cancel()
@@ -241,20 +299,47 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
   // Mappers: wire (ReadableMap/Array) → Kotlin
   // ---------------------------------------------------------------------------
 
+  // GATED on beekon native 0.0.9 (sealed BeekonConfig) — does not compile against
+  // the pinned 0.0.8 dep (the flat BeekonConfig(...) constructor). Switches on the
+  // wire `mode` (cloud-mode-v1 §2) to build the matching sealed arm. A cloud
+  // configuration with an empty/invalid projectKey throws
+  // BeekonException.InvalidConfiguration, which the configure() catch turns into a
+  // promise rejection via errorCode().
   private fun wireToConfig(map: ReadableMap): BeekonConfig {
-    val sync =
-      if (map.hasKey("sync") && !map.isNull("sync")) {
-        map.getMap("sync")?.let { wireToSyncConfig(it) }
-      } else {
-        null
-      }
     val notification =
       if (map.hasKey("notification") && !map.isNull("notification")) {
         map.getMap("notification")?.let { wireToNotification(it) }
       } else {
         null
       }
-    return BeekonConfig(
+
+    if (optString(map, "mode") == "cloud") {
+      val projectKey = optString(map, "projectKey") ?: ""
+      val endpoint = optString(map, "endpoint")
+      // Omitted endpoint → fall back to the constructor's baked-in default.
+      return if (endpoint != null) {
+        BeekonConfig.Cloud(
+          projectKey = projectKey,
+          endpoint = endpoint,
+          notification = notification ?: NotificationConfig(),
+          logLevel = toLogLevel(optString(map, "logLevel")),
+        )
+      } else {
+        BeekonConfig.Cloud(
+          projectKey = projectKey,
+          notification = notification ?: NotificationConfig(),
+          logLevel = toLogLevel(optString(map, "logLevel")),
+        )
+      }
+    }
+
+    val sync =
+      if (map.hasKey("sync") && !map.isNull("sync")) {
+        map.getMap("sync")?.let { wireToSyncConfig(it) }
+      } else {
+        null
+      }
+    return BeekonConfig.SelfManaged(
       minTimeBetweenLocationsSeconds =
         map.getDouble("minTimeBetweenLocationsSeconds").toLong(),
       minDistanceBetweenLocationsMeters =
@@ -268,6 +353,7 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
       // Passed through verbatim; absent/null means unset — the SDK falls through
       // to the manifest meta-data, then evaluation (license-format-v1 §9).
       licenseKey = optString(map, "licenseKey"),
+      logLevel = toLogLevel(optString(map, "logLevel")),
     )
   }
 
@@ -283,6 +369,7 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
       headers = entriesToMap(map.getArray("headers")),
       intervalSeconds = map.getDouble("intervalSeconds").toLong(),
       batchSize = map.getDouble("batchSize").toInt(),
+      syncThreshold = if (map.hasKey("syncThreshold")) map.getDouble("syncThreshold").toInt() else 0,
       auth = auth,
     )
   }
@@ -432,6 +519,27 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     return m
   }
 
+  private fun permissionStatusToWire(p: PermissionStatus): WritableMap {
+    val m = Arguments.createMap()
+    m.putString("level", permissionLevelToWire(p.level))
+    // '' is the wire encoding of null (not granted).
+    m.putString("accuracy", p.accuracy?.let { permissionAccuracyToWire(it) } ?: "")
+    return m
+  }
+
+  private fun permissionLevelToWire(l: PermissionStatus.Level): String = when (l) {
+    PermissionStatus.Level.NotDetermined -> "notDetermined"
+    PermissionStatus.Level.Denied -> "denied"
+    PermissionStatus.Level.Restricted -> "restricted"
+    PermissionStatus.Level.Foreground -> "foreground"
+    PermissionStatus.Level.Background -> "background"
+  }
+
+  private fun permissionAccuracyToWire(a: PermissionStatus.Accuracy): String = when (a) {
+    PermissionStatus.Accuracy.Full -> "full"
+    PermissionStatus.Accuracy.Reduced -> "reduced"
+  }
+
   private fun syncStatusToWire(s: SyncStatus): WritableMap {
     val m = Arguments.createMap()
     when (s) {
@@ -484,6 +592,16 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     return m
   }
 
+  private fun logEntryToWire(e: LogEntry): WritableMap {
+    val m = Arguments.createMap()
+    m.putString("id", e.id)
+    m.putDouble("timestampMs", e.timestamp.toEpochMilli().toDouble())
+    m.putString("level", e.level.wire)
+    m.putString("category", e.category)
+    m.putString("message", e.message)
+    return m
+  }
+
   private fun putNullableDouble(map: WritableMap, key: String, value: Double?) {
     if (value == null) map.putNull(key) else map.putDouble(key, value)
   }
@@ -514,11 +632,18 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     else -> AuthBodyFormat.Form
   }
 
+  // Wire token (lowercase) -> native LogLevel; unknown/absent defaults to Info.
+  private fun toLogLevel(s: String?): LogLevel =
+    LogLevel.fromWire(s ?: "") ?: LogLevel.Info
+
+  // GATED on beekon native 0.0.9 (StopReason.CloudModeUnavailable) — the new arm
+  // does not exist on the pinned 0.0.8 dep, so this `when` is non-exhaustive there.
   private fun stopReasonToWire(r: StopReason): String = when (r) {
     StopReason.User -> "user"
     StopReason.PermissionDenied -> "permissionDenied"
     StopReason.LocationServicesDisabled -> "locationServicesDisabled"
     StopReason.LocationUnavailable -> "locationUnavailable"
+    StopReason.CloudModeUnavailable -> "cloudModeUnavailable"
     StopReason.System -> "system"
   }
 
@@ -580,6 +705,6 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     // Reported to the native verifier via setWrapperInfo (diagnostics only — the
     // verifier consumes only the product). Keep in sync with package.json
     // "version" on release.
-    private const val WRAPPER_VERSION = "0.0.7"
+    private const val WRAPPER_VERSION = "0.1.0"
   }
 }

package/ios/BeekonRn.mm

@@ -35,6 +35,9 @@
         }
         onLicenseStatus:^(NSDictionary *_Nonnull ls) {
           [weakSelf emitOnLicenseStatus:ls];
+        }
+        onLog:^(NSDictionary *_Nonnull e) {
+          [weakSelf emitOnLog:e];
         }];
   }
   return self;
@@ -147,6 +150,43 @@
   [_impl licenseStatusWithResolver:resolve rejecter:reject];
 }
 
+- (void)getPermissionStatus:(RCTPromiseResolveBlock)resolve
+                     reject:(RCTPromiseRejectBlock)reject {
+  [_impl getPermissionStatusWithResolver:resolve rejecter:reject];
+}
+
+// MARK: - Diagnostic logs
+
+- (void)getLog:(double)fromMs
+          toMs:(double)toMs
+       resolve:(RCTPromiseResolveBlock)resolve
+        reject:(RCTPromiseRejectBlock)reject {
+  [_impl getLogFromMs:fromMs toMs:toMs resolver:resolve rejecter:reject];
+}
+
+- (void)exportLog:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject {
+  [_impl exportLogWithResolver:resolve rejecter:reject];
+}
+
+- (void)clearLog:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject {
+  [_impl clearLogWithResolver:resolve rejecter:reject];
+}
+
+- (void)setLogLevel:(NSString *)level
+            resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject {
+  [_impl setLogLevel:level resolver:resolve rejecter:reject];
+}
+
+- (void)log:(NSString *)level
+    message:(NSString *)message
+    resolve:(RCTPromiseResolveBlock)resolve
+     reject:(RCTPromiseRejectBlock)reject {
+  [_impl logWithLevel:level message:message resolver:resolve rejecter:reject];
+}
+
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params {
   return std::make_shared<facebook::react::NativeBeekonRnSpecJSI>(params);

package/ios/BeekonRn.swift

@@ -24,6 +24,7 @@ import BeekonKit
   private let onSyncStatusCb: (NSDictionary) -> Void
   private let onAuthTokensCb: (NSDictionary) -> Void
   private let onLicenseStatusCb: (NSDictionary) -> Void
+  private let onLogCb: (NSDictionary) -> Void
 
   private var stateTask: Task<Void, Never>?
   private var locationsTask: Task<Void, Never>?
@@ -31,11 +32,12 @@ import BeekonKit
   private var syncStatusTask: Task<Void, Never>?
   private var authTokensTask: Task<Void, Never>?
   private var licenseStatusTask: Task<Void, Never>?
+  private var logsTask: Task<Void, Never>?
 
   // Reported to the native verifier via setWrapperInfo (diagnostics only — the
   // verifier consumes only the product). Keep in sync with package.json
   // "version" on release.
-  private static let wrapperVersion = "0.0.7"
+  private static let wrapperVersion = "0.1.0"
 
   @objc public init(
     onState: @escaping (NSDictionary) -> Void,
@@ -43,7 +45,8 @@ import BeekonKit
     onGeofenceEvent: @escaping (NSDictionary) -> Void,
     onSyncStatus: @escaping (NSDictionary) -> Void,
     onAuthTokens: @escaping (NSDictionary) -> Void,
-    onLicenseStatus: @escaping (NSDictionary) -> Void
+    onLicenseStatus: @escaping (NSDictionary) -> Void,
+    onLog: @escaping (NSDictionary) -> Void
   ) {
     // Identify this wrapper to the native verifier (license-format-v1 §11) before
     // any configure() can run — a direct native call (nonisolated static),
@@ -55,6 +58,7 @@ import BeekonKit
     self.onSyncStatusCb = onSyncStatus
     self.onAuthTokensCb = onAuthTokens
     self.onLicenseStatusCb = onLicenseStatus
+    self.onLogCb = onLog
     super.init()
     self.stateTask = Task { [weak self] in
       guard let self = self else { return }
@@ -92,6 +96,12 @@ import BeekonKit
         self.onLicenseStatusCb(self.licenseStatusToWire(status))
       }
     }
+    self.logsTask = Task { [weak self] in
+      guard let self = self else { return }
+      for await entry in await Beekon.shared.logs {
+        self.onLogCb(self.logEntryToWire(entry))
+      }
+    }
   }
 
   @objc public func invalidate() {
@@ -101,12 +111,14 @@ import BeekonKit
     syncStatusTask?.cancel()
     authTokensTask?.cancel()
     licenseStatusTask?.cancel()
+    logsTask?.cancel()
     stateTask = nil
     locationsTask = nil
     geofenceEventsTask = nil
     syncStatusTask = nil
     authTokensTask = nil
     licenseStatusTask = nil
+    logsTask = nil
   }
 
   /// Register Beekon's background-refresh task and install cold-launch hooks.
@@ -123,11 +135,22 @@ import BeekonKit
   @objc public func configure(
     _ config: NSDictionary,
     resolver resolve: @escaping @Sendable (Any?) -> Void,
-    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> Void
   ) {
+    // GATED on beekon native 0.0.9 (sealed BeekonConfig) — does not compile
+    // against the pinned 0.0.8 dep. `wireToConfig` now throws: the cloud arm
+    // (`try BeekonConfig.cloud(...)`) raises BeekonError.invalidConfiguration on
+    // an empty/invalid projectKey, which we surface via the existing reject path.
+    //
     // Convert the non-Sendable NSDictionary to a Sendable BeekonConfig before
     // crossing into the Task closure.
-    let cfg = wireToConfig(config)
+    let cfg: BeekonConfig
+    do {
+      cfg = try wireToConfig(config)
+    } catch {
+      reject(errorCode(error), error.localizedDescription, error)
+      return
+    }
     Task {
       await Beekon.shared.configure(cfg)
       resolve(nil)
@@ -322,9 +345,104 @@ import BeekonKit
     }
   }
 
+  @objc public func getPermissionStatusWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    // `getPermissionStatus()` is `nonisolated` + synchronous — no Task/await.
+    resolve(permissionStatusToWire(Beekon.shared.getPermissionStatus()))
+  }
+
+  // MARK: - Diagnostic logs (spec diagnostics/log-format-v1)
+
+  @objc public func getLogFromMs(
+    _ fromMs: Double,
+    toMs: Double,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    Task { [weak self] in
+      guard let self = self else { return }
+      do {
+        let from = Date(timeIntervalSince1970: fromMs / 1000.0)
+        let to = Date(timeIntervalSince1970: toMs / 1000.0)
+        let entries = try await Beekon.shared.getLog(from: from, to: to)
+        resolve(entries.map { self.logEntryToWire($0) })
+      } catch {
+        reject(self.errorCode(error), error.localizedDescription, error)
+      }
+    }
+  }
+
+  @objc public func exportLogWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    Task { [weak self] in
+      guard let self = self else { return }
+      do {
+        resolve(try await Beekon.shared.exportLog())
+      } catch {
+        reject(self.errorCode(error), error.localizedDescription, error)
+      }
+    }
+  }
+
+  @objc public func clearLogWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    Task { [weak self] in
+      guard let self = self else { return }
+      do {
+        try await Beekon.shared.clearLog()
+        resolve(nil)
+      } catch {
+        reject(self.errorCode(error), error.localizedDescription, error)
+      }
+    }
+  }
+
+  @objc public func setLogLevel(
+    _ level: String,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    // setLogLevel is nonisolated on the actor — callable synchronously.
+    Beekon.shared.setLogLevel(logLevelFromWire(level))
+    resolve(nil)
+  }
+
+  @objc public func logWithLevel(
+    _ level: String,
+    message: String,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    Beekon.shared.log(logLevelFromWire(level), message)
+    resolve(nil)
+  }
+
   // MARK: - Mappers: wire (NSDictionary/NSArray) → Beekon
 
-  private func wireToConfig(_ d: NSDictionary) -> BeekonConfig {
+  // GATED on beekon native 0.0.9 (sealed BeekonConfig) — does not compile against
+  // the pinned 0.0.8 dep (the flat BeekonConfig(...) init). Switches on the wire
+  // `mode` (cloud-mode-v1 §2) to build the matching sealed arm. The cloud factory
+  // is throwing (`try BeekonConfig.cloud(...)`): an empty/invalid projectKey
+  // raises BeekonError.invalidConfiguration, propagated to configure()'s reject.
+  // iOS has NO `notification`, so the cloud arm omits it.
+  private func wireToConfig(_ d: NSDictionary) throws -> BeekonConfig {
+    if d["mode"] as? String == "cloud" {
+      let projectKey = (d["projectKey"] as? String) ?? ""
+      // Omitted endpoint → the baked-in Beekon Cloud default.
+      let endpoint = (d["endpoint"] as? String) ?? "https://api.getbeekon.com"
+      return try BeekonConfig.cloud(
+        projectKey: projectKey,
+        endpoint: endpoint,
+        logLevel: logLevelFromWire(d["logLevel"] as? String)
+      )
+    }
+
     let minTime =
       (d["minTimeBetweenLocationsSeconds"] as? NSNumber)?.doubleValue ?? 30
     let minDist =
@@ -343,6 +461,7 @@ import BeekonKit
           headers: entriesToDict((s["headers"] as? NSArray) ?? []),
           intervalSeconds: (s["intervalSeconds"] as? NSNumber)?.doubleValue ?? 300,
           batchSize: (s["batchSize"] as? NSNumber)?.intValue ?? 100,
+          syncThreshold: (s["syncThreshold"] as? NSNumber)?.intValue ?? 0,
           auth: auth
         )
       } else {
@@ -352,8 +471,9 @@ import BeekonKit
       }
     }
 
-    // `notification` is Android-only — iOS ignores it.
-    return BeekonConfig(
+    // `notification` is Android-only — iOS ignores it (the selfManaged factory
+    // takes no notification parameter on iOS).
+    return BeekonConfig.selfManaged(
       minTimeBetweenLocationsSeconds: minTime,
       minDistanceBetweenLocationsMeters: minDist,
       accuracyMode: accuracyModeFromWire(d["accuracyMode"] as? String),
@@ -363,7 +483,8 @@ import BeekonKit
       sync: sync,
       // Passed through verbatim; nil/blank means unset — the SDK falls through to
       // the Info.plist value, then evaluation (license-format-v1 §9).
-      licenseKey: d["licenseKey"] as? String
+      licenseKey: d["licenseKey"] as? String,
+      logLevel: logLevelFromWire(d["logLevel"] as? String)
     )
   }
 
@@ -471,6 +592,44 @@ import BeekonKit
     ]
   }
 
+  private func logEntryToWire(_ e: LogEntry) -> NSDictionary {
+    return [
+      "id": e.id,
+      "timestampMs": e.timestamp.timeIntervalSince1970 * 1000.0,
+      "level": e.level.rawValue,
+      "category": e.category,
+      "message": e.message,
+    ]
+  }
+
+  private func permissionStatusToWire(_ p: PermissionStatus) -> NSDictionary {
+    return [
+      "level": permissionLevelToWire(p.level),
+      // "" is the wire encoding of null (not granted).
+      "accuracy": p.accuracy.map { permissionAccuracyToWire($0) } ?? "",
+    ]
+  }
+
+  private func permissionLevelToWire(_ l: PermissionStatus.Level) -> String {
+    switch l {
+    case .notDetermined: return "notDetermined"
+    case .denied: return "denied"
+    case .restricted: return "restricted"
+    case .foreground: return "foreground"
+    case .background: return "background"
+    // BeekonKit enums are non-frozen (library-evolution binary); handle unknowns.
+    @unknown default: return "notDetermined"
+    }
+  }
+
+  private func permissionAccuracyToWire(_ a: PermissionStatus.Accuracy) -> String {
+    switch a {
+    case .full: return "full"
+    case .reduced: return "reduced"
+    @unknown default: return "full"
+    }
+  }
+
   private func stateToWire(_ s: BeekonState) -> NSDictionary {
     switch s {
     case .idle:
@@ -590,12 +749,21 @@ import BeekonKit
     }
   }
 
+  // Wire token (LogLevel.rawValue, lowercase) -> LogLevel; unknown defaults to .info.
+  private func logLevelFromWire(_ s: String?) -> LogLevel {
+    LogLevel(rawValue: s ?? "") ?? .info
+  }
+
+  // GATED on beekon native 0.0.9 (StopReason.cloudModeUnavailable) — the new case
+  // does not exist on the pinned 0.0.8 dep. (Non-frozen enum, so the existing
+  // `@unknown default` already keeps this compiling either way.)
   private func stopReasonToWire(_ r: StopReason) -> String {
     switch r {
     case .user: return "user"
     case .permissionDenied: return "permissionDenied"
     case .locationServicesDisabled: return "locationServicesDisabled"
     case .locationUnavailable: return "locationUnavailable"
+    case .cloudModeUnavailable: return "cloudModeUnavailable"
     case .system: return "system"
     @unknown default: return "system"
     }

package/ios/Frameworks/BeekonKit.xcframework/Info.plist

@@ -8,32 +8,32 @@
 			<key>BinaryPath</key>
 			<string>BeekonKit.framework/BeekonKit</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>BeekonKit.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>BeekonKit.framework/BeekonKit</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>BeekonKit.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/ios/Frameworks/BeekonKit.xcframework/LICENSE.txt

@@ -1,9 +1,9 @@
 Beekon SDK
-Copyright (c) 2026 wayqteam. All rights reserved.
+Copyright (c) 2026 beekonlabs. All rights reserved.
 
 This software is licensed for evaluation use only. No production deployment,
 redistribution, sublicensing, or commercial use is permitted without a separate
-written agreement with wayqteam.
+written agreement with beekonlabs.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
@@ -11,4 +11,4 @@ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY ARISING
 FROM USE OF THE SOFTWARE.
 
-For licensing inquiries: contact wayqteam.
+For licensing inquiries: contact beekonlabs.