@wayq/beekon-rn 0.0.5 → 0.0.7

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

@@ -9,15 +9,22 @@ import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import `in`.wayq.beekon.AccuracyMode
 import `in`.wayq.beekon.ActivityType
+import `in`.wayq.beekon.AuthBodyFormat
+import `in`.wayq.beekon.AuthConfig
+import `in`.wayq.beekon.AuthResponseMapping
+import `in`.wayq.beekon.AuthStrategy
+import `in`.wayq.beekon.AuthTokens
 import `in`.wayq.beekon.Beekon
 import `in`.wayq.beekon.BeekonConfig
 import `in`.wayq.beekon.BeekonException
 import `in`.wayq.beekon.BeekonGeofence
 import `in`.wayq.beekon.BeekonState
 import `in`.wayq.beekon.GeofenceEvent
+import `in`.wayq.beekon.LicenseStatus
 import `in`.wayq.beekon.Location
 import `in`.wayq.beekon.LocationQuality
 import `in`.wayq.beekon.LocationTrigger
+import `in`.wayq.beekon.LocationUnavailableReason
 import `in`.wayq.beekon.MotionState
 import `in`.wayq.beekon.NotificationConfig
 import `in`.wayq.beekon.StationaryMode
@@ -43,6 +50,11 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
   private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
 
   init {
+    // Identify this wrapper to the native verifier (license-format-v1 §11) before
+    // any configure() can run — a direct native call, deliberately not bridged to
+    // JS. The module is constructed before its first method dispatch, so this is
+    // always set first.
+    Beekon.setWrapperInfo("rn", WRAPPER_VERSION)
     // No Beekon.initialize() — the SDK auto-initializes via AndroidX Startup.
     scope.launch { Beekon.state.collect { emitOnState(stateToWire(it)) } }
     scope.launch { Beekon.locations.collect { emitOnLocation(locationToWire(it)) } }
@@ -50,6 +62,8 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
       Beekon.geofenceEvents.collect { emitOnGeofenceEvent(geofenceEventToWire(it)) }
     }
     scope.launch { Beekon.syncStatus.collect { emitOnSyncStatus(syncStatusToWire(it)) } }
+    scope.launch { Beekon.authChanges.collect { emitOnAuthTokens(tokenRefreshToWire(it)) } }
+    scope.launch { Beekon.licenseStatus.collect { emitOnLicenseStatus(licenseStatusToWire(it)) } }
   }
 
   // ---------------------------------------------------------------------------
@@ -87,12 +101,13 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     }
   }
 
-  // Android has no native resumeIfNeeded — Beekon.start() rehydrates the
-  // persisted intent (mirrors the Flutter plugin).
+  // Calls the guarded native resume (Beekon.resumeIfNeeded), which only
+  // re-adopts a previously-active, non-user-stopped session — a no-op when
+  // already Tracking or when the user explicitly stopped (mirrors iOS).
   override fun resumeIfNeeded(promise: Promise) {
     scope.launch {
       try {
-        Beekon.start()
+        Beekon.resumeIfNeeded()
         promise.resolve(null)
       } catch (t: Throwable) {
         promise.reject(errorCode(t), t.message ?: "resumeIfNeeded failed", t)
@@ -100,6 +115,21 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  override fun getCurrentLocation(timeoutMs: Double, accuracy: String, promise: Promise) {
+    scope.launch {
+      try {
+        // Empty accuracy is the wire encoding of "use the configured mode".
+        val mode = if (accuracy.isEmpty()) null else toAccuracyMode(accuracy)
+        val loc = Beekon.getCurrentLocation(timeoutMs.toLong(), mode)
+        val arr: WritableArray = Arguments.createArray()
+        if (loc != null) arr.pushMap(locationToWire(loc))
+        promise.resolve(arr)
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "getCurrentLocation failed", t)
+      }
+    }
+  }
+
   // ---------------------------------------------------------------------------
   // History
   // ---------------------------------------------------------------------------
@@ -193,6 +223,15 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  // ---------------------------------------------------------------------------
+  // License (observational only — never blocks; license-format-v1 §8)
+  // ---------------------------------------------------------------------------
+
+  override fun licenseStatus(promise: Promise) {
+    // StateFlow.value is the current, synchronously-readable status.
+    promise.resolve(licenseStatusToWire(Beekon.licenseStatus.value))
+  }
+
   override fun invalidate() {
     super.invalidate()
     scope.cancel()
@@ -226,27 +265,86 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
       detectActivity = map.getBoolean("detectActivity"),
       sync = sync,
       notification = notification ?: NotificationConfig(),
+      // 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"),
     )
   }
 
-  private fun wireToSyncConfig(map: ReadableMap): SyncConfig =
-    SyncConfig(
+  private fun wireToSyncConfig(map: ReadableMap): SyncConfig {
+    val auth =
+      if (map.hasKey("auth") && !map.isNull("auth")) {
+        map.getMap("auth")?.let { wireToAuthConfig(it) }
+      } else {
+        null
+      }
+    return SyncConfig(
       url = map.getString("url") ?: "",
       headers = entriesToMap(map.getArray("headers")),
       intervalSeconds = map.getDouble("intervalSeconds").toLong(),
       batchSize = map.getDouble("batchSize").toInt(),
+      auth = auth,
     )
+  }
+
+  private fun wireToAuthConfig(map: ReadableMap): AuthConfig {
+    val expiresAt =
+      if (map.hasKey("expiresAtMs") && !map.isNull("expiresAtMs")) {
+        // Wire carries epoch millis; the native recipe wants epoch seconds.
+        (map.getDouble("expiresAtMs") / 1000.0).toLong()
+      } else {
+        null
+      }
+    val seedEpoch =
+      if (map.hasKey("seedEpoch") && !map.isNull("seedEpoch")) {
+        map.getDouble("seedEpoch").toLong()
+      } else {
+        null
+      }
+    val responseMapping =
+      if (map.hasKey("responseMapping") && !map.isNull("responseMapping")) {
+        map.getMap("responseMapping")?.let { wireToResponseMapping(it) } ?: AuthResponseMapping()
+      } else {
+        AuthResponseMapping()
+      }
+    return AuthConfig(
+      accessToken = optString(map, "accessToken"),
+      refreshToken = optString(map, "refreshToken"),
+      expiresAt = expiresAt,
+      strategy = toAuthStrategy(map.getString("strategy")),
+      refreshUrl = optString(map, "refreshUrl"),
+      refreshPayload = entriesToMap(map.getArray("refreshPayload")),
+      refreshHeaders = entriesToMap(map.getArray("refreshHeaders")),
+      refreshBodyFormat = toRefreshBodyFormat(map.getString("refreshBodyFormat")),
+      responseMapping = responseMapping,
+      skewMarginSeconds = map.getDouble("skewMarginSeconds").toLong(),
+      seedEpoch = seedEpoch,
+    )
+  }
+
+  private fun wireToResponseMapping(map: ReadableMap): AuthResponseMapping =
+    AuthResponseMapping(
+      accessToken = optString(map, "accessToken"),
+      refreshToken = optString(map, "refreshToken"),
+      expiresIn = optString(map, "expiresIn"),
+      expiresAt = optString(map, "expiresAt"),
+    )
+
+  private fun optString(map: ReadableMap, key: String): String? =
+    if (map.hasKey(key) && !map.isNull(key)) map.getString(key) else null
 
   private fun wireToNotification(map: ReadableMap): NotificationConfig {
     val title =
       if (map.hasKey("title") && !map.isNull("title")) map.getString("title") else null
     val text =
       if (map.hasKey("text") && !map.isNull("text")) map.getString("text") else null
+    val smallIcon =
+      if (map.hasKey("smallIcon") && !map.isNull("smallIcon")) map.getString("smallIcon") else null
     // Use the data-class default for `title` when the wire value is absent.
     return if (title != null) {
-      NotificationConfig(title = title, text = text)
+      NotificationConfig(title = title, text = text, smallIcon = smallIcon)
     } else {
-      NotificationConfig(text = text)
+      NotificationConfig(text = text, smallIcon = smallIcon)
     }
   }
 
@@ -347,6 +445,45 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     return m
   }
 
+  private fun tokenRefreshToWire(t: AuthTokens): WritableMap {
+    val m = Arguments.createMap()
+    m.putString("accessToken", t.accessToken)
+    val refreshToken = t.refreshToken
+    if (refreshToken != null) m.putString("refreshToken", refreshToken) else m.putNull("refreshToken")
+    val expiresAt = t.expiresAt
+    // Native epoch seconds → wire epoch millis.
+    if (expiresAt != null) m.putDouble("expiresAtMs", (expiresAt * 1000L).toDouble()) else m.putNull("expiresAtMs")
+    m.putDouble("epoch", t.epoch.toDouble())
+    return m
+  }
+
+  // Reads the SDK's wire-stable names (no validation here). `tier`/`entitlements`
+  // populate only for Licensed; `reason` only for Invalid.
+  private fun licenseStatusToWire(s: LicenseStatus): WritableMap {
+    val m = Arguments.createMap()
+    m.putString("status", s.wireName)
+    when (s) {
+      is LicenseStatus.Licensed -> {
+        m.putString("tier", s.tier)
+        val arr: WritableArray = Arguments.createArray()
+        for (e in s.entitlements) arr.pushString(e)
+        m.putArray("entitlements", arr)
+        m.putNull("reason")
+      }
+      is LicenseStatus.Invalid -> {
+        m.putNull("tier")
+        m.putArray("entitlements", Arguments.createArray())
+        m.putString("reason", s.reason.wireName)
+      }
+      else -> {
+        m.putNull("tier")
+        m.putArray("entitlements", Arguments.createArray())
+        m.putNull("reason")
+      }
+    }
+    return m
+  }
+
   private fun putNullableDouble(map: WritableMap, key: String, value: Double?) {
     if (value == null) map.putNull(key) else map.putDouble(key, value)
   }
@@ -367,6 +504,16 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     else -> StationaryMode.Pause
   }
 
+  private fun toAuthStrategy(s: String?): AuthStrategy = when (s) {
+    "raw" -> AuthStrategy.Raw
+    else -> AuthStrategy.Bearer
+  }
+
+  private fun toRefreshBodyFormat(s: String?): AuthBodyFormat = when (s) {
+    "json" -> AuthBodyFormat.Json
+    else -> AuthBodyFormat.Form
+  }
+
   private fun stopReasonToWire(r: StopReason): String = when (r) {
     StopReason.User -> "user"
     StopReason.PermissionDenied -> "permissionDenied"
@@ -419,10 +566,20 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
   private fun errorCode(t: Throwable): String = when (t) {
     is BeekonException.StorageException -> "STORAGE_FAILURE"
     is BeekonException.InvalidGeofence -> "INVALID_GEOFENCE"
+    is BeekonException.LocationUnavailable -> when (t.reason) {
+      LocationUnavailableReason.PermissionDenied -> "PERMISSION_DENIED"
+      LocationUnavailableReason.LocationServicesDisabled -> "LOCATION_SERVICES_DISABLED"
+      LocationUnavailableReason.Unavailable -> "LOCATION_UNAVAILABLE"
+    }
     else -> "INTERNAL_ERROR"
   }
 
   companion object {
     const val NAME = NativeBeekonRnSpec.NAME
+
+    // 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"
   }
 }

package/ios/BeekonRn.mm

@@ -29,6 +29,12 @@
         }
         onSyncStatus:^(NSDictionary *_Nonnull st) {
           [weakSelf emitOnSyncStatus:st];
+        }
+        onAuthTokens:^(NSDictionary *_Nonnull t) {
+          [weakSelf emitOnAuthTokens:t];
+        }
+        onLicenseStatus:^(NSDictionary *_Nonnull ls) {
+          [weakSelf emitOnLicenseStatus:ls];
         }];
   }
   return self;
@@ -72,6 +78,16 @@
   [_impl resumeIfNeededWithResolver:resolve rejecter:reject];
 }
 
+- (void)getCurrentLocation:(double)timeoutMs
+                  accuracy:(NSString *)accuracy
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject {
+  [_impl getCurrentLocationTimeoutMs:timeoutMs
+                            accuracy:accuracy
+                            resolver:resolve
+                            rejecter:reject];
+}
+
 // MARK: - History
 
 - (void)getLocations:(double)fromMs
@@ -124,6 +140,13 @@
   [_impl listGeofencesWithResolver:resolve rejecter:reject];
 }
 
+// MARK: - License
+
+- (void)licenseStatus:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject {
+  [_impl licenseStatusWithResolver: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

@@ -22,22 +22,39 @@ import BeekonKit
   private let onLocationCb: (NSDictionary) -> Void
   private let onGeofenceEventCb: (NSDictionary) -> Void
   private let onSyncStatusCb: (NSDictionary) -> Void
+  private let onAuthTokensCb: (NSDictionary) -> Void
+  private let onLicenseStatusCb: (NSDictionary) -> Void
 
   private var stateTask: Task<Void, Never>?
   private var locationsTask: Task<Void, Never>?
   private var geofenceEventsTask: Task<Void, Never>?
   private var syncStatusTask: Task<Void, Never>?
+  private var authTokensTask: Task<Void, Never>?
+  private var licenseStatusTask: 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"
 
   @objc public init(
     onState: @escaping (NSDictionary) -> Void,
     onLocation: @escaping (NSDictionary) -> Void,
     onGeofenceEvent: @escaping (NSDictionary) -> Void,
-    onSyncStatus: @escaping (NSDictionary) -> Void
+    onSyncStatus: @escaping (NSDictionary) -> Void,
+    onAuthTokens: @escaping (NSDictionary) -> Void,
+    onLicenseStatus: @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),
+    // deliberately not bridged to JS.
+    Beekon.setWrapperInfo(product: "rn", version: BeekonRnImpl.wrapperVersion)
     self.onStateCb = onState
     self.onLocationCb = onLocation
     self.onGeofenceEventCb = onGeofenceEvent
     self.onSyncStatusCb = onSyncStatus
+    self.onAuthTokensCb = onAuthTokens
+    self.onLicenseStatusCb = onLicenseStatus
     super.init()
     self.stateTask = Task { [weak self] in
       guard let self = self else { return }
@@ -63,6 +80,18 @@ import BeekonKit
         self.onSyncStatusCb(self.syncStatusToWire(status))
       }
     }
+    self.authTokensTask = Task { [weak self] in
+      guard let self = self else { return }
+      for await tokens in await Beekon.shared.authChanges {
+        self.onAuthTokensCb(self.authTokensToWire(tokens))
+      }
+    }
+    self.licenseStatusTask = Task { [weak self] in
+      guard let self = self else { return }
+      for await status in await Beekon.shared.licenseStatusUpdates {
+        self.onLicenseStatusCb(self.licenseStatusToWire(status))
+      }
+    }
   }
 
   @objc public func invalidate() {
@@ -70,10 +99,14 @@ import BeekonKit
     locationsTask?.cancel()
     geofenceEventsTask?.cancel()
     syncStatusTask?.cancel()
+    authTokensTask?.cancel()
+    licenseStatusTask?.cancel()
     stateTask = nil
     locationsTask = nil
     geofenceEventsTask = nil
     syncStatusTask = nil
+    authTokensTask = nil
+    licenseStatusTask = nil
   }
 
   /// Register Beekon's background-refresh task and install cold-launch hooks.
@@ -132,6 +165,29 @@ import BeekonKit
     }
   }
 
+  @objc public func getCurrentLocationTimeoutMs(
+    _ timeoutMs: Double,
+    accuracy: String,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    // Empty accuracy is the wire encoding of "use the configured mode".
+    let mode: AccuracyMode? = accuracy.isEmpty ? nil : accuracyModeFromWire(accuracy)
+    Task { [weak self] in
+      guard let self = self else { return }
+      do {
+        let location = try await Beekon.shared.getCurrentLocation(
+          timeout: timeoutMs / 1000.0,
+          accuracy: mode
+        )
+        // 0- or 1-element array — empty means timeout / no fix.
+        resolve(location.map { [self.locationToWire($0)] } ?? [])
+      } catch {
+        reject(self.errorCode(error), error.localizedDescription, error)
+      }
+    }
+  }
+
   // MARK: - History
 
   @objc public func getLocationsFromMs(
@@ -253,6 +309,19 @@ import BeekonKit
     }
   }
 
+  // MARK: - License (observational only — never blocks; license-format-v1 §8)
+
+  @objc public func licenseStatusWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    Task { [weak self] in
+      guard let self = self else { return }
+      // `licenseStatus` is an actor-isolated property — read it with `await`.
+      resolve(self.licenseStatusToWire(await Beekon.shared.licenseStatus))
+    }
+  }
+
   // MARK: - Mappers: wire (NSDictionary/NSArray) → Beekon
 
   private func wireToConfig(_ d: NSDictionary) -> BeekonConfig {
@@ -266,14 +335,21 @@ import BeekonKit
 
     var sync: SyncConfig?
     if let s = d["sync"] as? NSDictionary,
-      let urlStr = s["url"] as? String,
-      let url = URL(string: urlStr) {
-      sync = SyncConfig(
-        url: url,
-        headers: entriesToDict((s["headers"] as? NSArray) ?? []),
-        intervalSeconds: (s["intervalSeconds"] as? NSNumber)?.doubleValue ?? 300,
-        batchSize: (s["batchSize"] as? NSNumber)?.intValue ?? 100
-      )
+      let urlStr = s["url"] as? String {
+      if let url = URL(string: urlStr) {
+        let auth = (s["auth"] as? NSDictionary).map { wireToAuthConfig($0) }
+        sync = SyncConfig(
+          url: url,
+          headers: entriesToDict((s["headers"] as? NSArray) ?? []),
+          intervalSeconds: (s["intervalSeconds"] as? NSNumber)?.doubleValue ?? 300,
+          batchSize: (s["batchSize"] as? NSNumber)?.intValue ?? 100,
+          auth: auth
+        )
+      } else {
+        // Don't silently drop the whole sync config on an unparseable URL —
+        // surface it so a malformed endpoint is diagnosable instead of a no-op.
+        NSLog("[BeekonRn] sync config ignored: url is not a valid URL: %@", urlStr)
+      }
     }
 
     // `notification` is Android-only — iOS ignores it.
@@ -284,7 +360,10 @@ import BeekonKit
       whenStationary: stationaryModeFromWire(d["whenStationary"] as? String),
       stationaryRadiusMeters: stationaryRadius,
       detectActivity: detectActivity,
-      sync: sync
+      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
     )
   }
 
@@ -321,6 +400,35 @@ import BeekonKit
     return out
   }
 
+  private func wireToAuthConfig(_ d: NSDictionary) -> AuthConfig {
+    // Wire carries epoch millis; the native recipe wants epoch seconds.
+    let expiresAt = (d["expiresAtMs"] as? NSNumber).map { $0.doubleValue / 1000.0 }
+    let responseMapping = (d["responseMapping"] as? NSDictionary)
+      .map { wireToResponseMapping($0) } ?? AuthResponseMapping()
+    return AuthConfig(
+      accessToken: d["accessToken"] as? String,
+      refreshToken: d["refreshToken"] as? String,
+      expiresAt: expiresAt,
+      strategy: authStrategyFromWire(d["strategy"] as? String),
+      refreshUrl: (d["refreshUrl"] as? String).flatMap { URL(string: $0) },
+      refreshPayload: entriesToDict((d["refreshPayload"] as? NSArray) ?? []),
+      refreshHeaders: entriesToDict((d["refreshHeaders"] as? NSArray) ?? []),
+      refreshBodyFormat: authBodyFormatFromWire(d["refreshBodyFormat"] as? String),
+      responseMapping: responseMapping,
+      skewMarginSeconds: (d["skewMarginSeconds"] as? NSNumber)?.doubleValue ?? 60,
+      seedEpoch: (d["seedEpoch"] as? NSNumber)?.intValue
+    )
+  }
+
+  private func wireToResponseMapping(_ d: NSDictionary) -> AuthResponseMapping {
+    return AuthResponseMapping(
+      accessToken: d["accessToken"] as? String,
+      refreshToken: d["refreshToken"] as? String,
+      expiresIn: d["expiresIn"] as? String,
+      expiresAt: d["expiresAt"] as? String
+    )
+  }
+
   // MARK: - Mappers: Beekon → wire (NSDictionary)
 
   private func locationToWire(_ loc: Location) -> NSDictionary {
@@ -390,6 +498,66 @@ import BeekonKit
     }
   }
 
+  private func authTokensToWire(_ t: AuthTokens) -> NSDictionary {
+    // NSDictionary literals can't carry `nil`; optionals collapse to `NSNull`,
+    // which the Codegen layer translates back to `null` on the JS side.
+    let d = NSMutableDictionary()
+    d["accessToken"] = t.accessToken
+    d["refreshToken"] = t.refreshToken.map { $0 as Any } ?? NSNull()
+    // Native epoch seconds → wire epoch millis.
+    d["expiresAtMs"] = t.expiresAt.map { ($0 * 1000.0) as Any } ?? NSNull()
+    d["epoch"] = t.epoch
+    return d
+  }
+
+  private func licenseStatusToWire(_ s: LicenseStatus) -> NSDictionary {
+    // NSDictionary literals can't carry `nil`; optionals collapse to `NSNull`,
+    // which the Codegen layer translates back to `null` on the JS side. iOS has
+    // no `.wireName`, so the wire-stable strings are written literally here (as
+    // with stateToWire / syncStatusToWire). No validation — the SDK already
+    // decided the status.
+    let d = NSMutableDictionary()
+    switch s {
+    case let .licensed(tier, entitlements):
+      d["status"] = "licensed"
+      d["tier"] = tier
+      d["entitlements"] = entitlements
+      d["reason"] = NSNull()
+    case let .invalid(reason):
+      d["status"] = "invalid"
+      d["tier"] = NSNull()
+      d["entitlements"] = [String]()
+      d["reason"] = reason.rawValue
+    case .evaluation:
+      d["status"] = "evaluation"
+      d["tier"] = NSNull()
+      d["entitlements"] = [String]()
+      d["reason"] = NSNull()
+    case .expired:
+      d["status"] = "expired"
+      d["tier"] = NSNull()
+      d["entitlements"] = [String]()
+      d["reason"] = NSNull()
+    case .updateEntitlementLapsed:
+      d["status"] = "updateEntitlementLapsed"
+      d["tier"] = NSNull()
+      d["entitlements"] = [String]()
+      d["reason"] = NSNull()
+    case .notDetermined:
+      d["status"] = "notDetermined"
+      d["tier"] = NSNull()
+      d["entitlements"] = [String]()
+      d["reason"] = NSNull()
+    // BeekonKit enums are non-frozen (library-evolution binary); handle unknowns.
+    @unknown default:
+      d["status"] = "notDetermined"
+      d["tier"] = NSNull()
+      d["entitlements"] = [String]()
+      d["reason"] = NSNull()
+    }
+    return d
+  }
+
   // MARK: - Enum mappers
 
   private func accuracyModeFromWire(_ s: String?) -> AccuracyMode {
@@ -408,6 +576,20 @@ import BeekonKit
     }
   }
 
+  private func authStrategyFromWire(_ s: String?) -> AuthStrategy {
+    switch s {
+    case "raw": return .raw
+    default: return .bearer
+    }
+  }
+
+  private func authBodyFormatFromWire(_ s: String?) -> AuthBodyFormat {
+    switch s {
+    case "json": return .json
+    default: return .form
+    }
+  }
+
   private func stopReasonToWire(_ r: StopReason) -> String {
     switch r {
     case .user: return "user"
@@ -483,6 +665,13 @@ import BeekonKit
       switch be {
       case .storage: return "STORAGE_FAILURE"
       case .invalidGeofence: return "INVALID_GEOFENCE"
+      case .locationUnavailable(let reason):
+        switch reason {
+        case .permissionDenied: return "PERMISSION_DENIED"
+        case .locationServicesDisabled: return "LOCATION_SERVICES_DISABLED"
+        case .unavailable: return "LOCATION_UNAVAILABLE"
+        @unknown default: return "LOCATION_UNAVAILABLE"
+        }
       @unknown default: return "INTERNAL_ERROR"
       }
     }

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>