@tempivo/sensor-beacon 1.1.4 → 1.1.5

package/CHANGELOG.md

@@ -6,7 +6,18 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
-<!-- Publish trigger: 1.1.4 not on npm until CI Trusted Publisher (ci.yml) runs. -->
+## [1.1.5] - 2026-09-08
+
+### Fixed
+
+- Android raw ProtoConfig GATT: wait for write ACK before read (long writes at MTU 23 no longer race).
+- Android: do not reject large set frames when the link stays at MTU 23; use ATT long write (`WRITE_TYPE_DEFAULT`).
+- Android: request MTU 517 once after a short post-connect delay; never gate or crash on mismatched MTU.
+- Partner BLE set: reject / strip cellular and server ProtoConfig fields so a rules write cannot wipe uplink settings.
+
+### Changed
+
+- Native Android module version `0.4.5` (rebuild required for Expo / RN apps).
 
 ## [1.1.4] - 2026-09-07
 

package/android/build.gradle

@@ -4,14 +4,14 @@ plugins {
 }
 
 group = 'com.tempivo.sensor.beacon'
-version = '0.4.4'
+version = '0.4.5'
 
 android {
   namespace "expo.modules.tempivosensorbeacon"
   defaultConfig {
     minSdk 26
     versionCode 1
-    versionName "0.4.4"
+    versionName "0.4.5"
   }
   compileOptions {
     sourceCompatibility JavaVersion.VERSION_17

package/android-aar/library/src/main/java/com/tempivo/sensor/beacon/EfentoRawConfigTransfer.kt

@@ -12,7 +12,7 @@ import android.bluetooth.BluetoothProfile
 import android.content.Context
 import android.os.Build
 import android.os.Handler
-import android.os.Looper
+import android.os.HandlerThread
 import java.util.UUID
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
@@ -23,6 +23,11 @@ import java.util.concurrent.atomic.AtomicReference
  *
  * Mirrors iOS `EfentoRawConfigTransfer`: one persistent GATT link reused across commands.
  * Disconnect the vendor SDK session before calling.
+ *
+ * Important Android details:
+ * - GATT work runs on a dedicated [HandlerThread] (not the main looper). Blocking the main
+ *   thread while posting `connectGatt` there deadlocks until timeout.
+ * - Service discovery starts on connect. Do not wait for `onMtuChanged` (often never fires).
  */
 internal object EfentoRawConfigTransfer {
     private val TRANSFER_SERVICE = UUID.fromString("6E20F700-6126-4FCD-99C1-EB8A182501A2")
@@ -47,7 +52,7 @@ internal object EfentoRawConfigTransfer {
         address: String,
         bluetoothMac: String,
         pin: String,
-        timeoutMs: Long = 25_000L,
+        timeoutMs: Long = 40_000L,
     ): ByteArray =
         link.runCommand(
             context = context.applicationContext,
@@ -65,7 +70,7 @@ internal object EfentoRawConfigTransfer {
         bluetoothMac: String,
         pin: String,
         proto: ByteArray,
-        timeoutMs: Long = 25_000L,
+        timeoutMs: Long = 40_000L,
     ) {
         link.runCommand(
             context = context.applicationContext,
@@ -83,7 +88,10 @@ internal object EfentoRawConfigTransfer {
 
     @SuppressLint("MissingPermission")
     private class Link {
-        private val handler = Handler(Looper.getMainLooper())
+        /** Dedicated BLE looper so connectGatt/callbacks never depend on the app main thread. */
+        private val bleThread =
+            HandlerThread("tempivo-raw-config-ble").apply { start() }
+        private val handler = Handler(bleThread.looper)
         private val lock = Any()
 
         private var gatt: BluetoothGatt? = null
@@ -92,6 +100,10 @@ internal object EfentoRawConfigTransfer {
         private var usingTransfer = true
         private var discoveryStarted = false
         private var connectedAddress: String? = null
+        private var negotiatedMtu = 23
+        private var mtuRequested = false
+        private var awaitingMtu = false
+        private var mtuAttempts = 0
 
         private var bluetoothMac = ""
         private var pin = ""
@@ -116,13 +128,13 @@ internal object EfentoRawConfigTransfer {
             timeoutMs: Long,
         ): ByteArray {
             var last: Throwable? = null
-            repeat(2) { attempt ->
+            repeat(3) { attempt ->
                 try {
                     return attemptCommand(context, address, bluetoothMac, pin, writeProto, timeoutMs)
                 } catch (e: Throwable) {
                     last = e
                     close()
-                    if (attempt == 0) Thread.sleep(1_000)
+                    if (attempt < 2) Thread.sleep(2_000L * (attempt + 1))
                 }
             }
             throw last ?: TempivoSensorException(TempivoSensorException.Code.UNKNOWN, "Raw config transfer failed.")
@@ -138,6 +150,10 @@ internal object EfentoRawConfigTransfer {
                 notifyChar = null
                 discoveryStarted = false
                 connectedAddress = null
+                negotiatedMtu = 23
+                mtuRequested = false
+                awaitingMtu = false
+                mtuAttempts = 0
                 doneLatch = null
                 resultRef.set(null)
             }
@@ -153,6 +169,7 @@ internal object EfentoRawConfigTransfer {
         ): ByteArray {
             val latch = CountDownLatch(1)
             val token: Long
+            val macKey = normalizeAddress(bluetoothMac.ifBlank { address })
             synchronized(lock) {
                 token = System.nanoTime()
                 commandToken = token
@@ -165,9 +182,18 @@ internal object EfentoRawConfigTransfer {
                 finished = false
                 doneLatch = latch
                 resultRef.set(null)
+                mtuAttempts = 0
 
                 val existing = gatt
-                if (existing != null && connectedAddress.equals(address, ignoreCase = true)) {
+                val sameLink =
+                    existing != null &&
+                        connectedAddress != null &&
+                        normalizeAddress(connectedAddress!!) == macKey &&
+                        writeChar != null &&
+                        notifyChar != null
+                if (sameLink) {
+                    // Re-request MTU on reused links if a large write is pending.
+                    mtuRequested = negotiatedMtu >= 100
                     handler.post { advance() }
                 } else {
                     runCatching { existing?.disconnect() }
@@ -176,7 +202,10 @@ internal object EfentoRawConfigTransfer {
                     writeChar = null
                     notifyChar = null
                     discoveryStarted = false
-                    connectedAddress = address
+                    negotiatedMtu = 23
+                    mtuRequested = false
+                    awaitingMtu = false
+                    mtuAttempts = 0
                     val adapter = bluetoothAdapter(context)
                         ?: throw TempivoSensorException(
                             TempivoSensorException.Code.RUNTIME_UNAVAILABLE,
@@ -188,9 +217,11 @@ internal object EfentoRawConfigTransfer {
                             "Bluetooth is not powered on.",
                         )
                     }
+                    // Always connect with the public Bluetooth MAC (CRC + stack). Avoid opaque SDK ids.
+                    val connectAddress = macKey
                     val device =
                         try {
-                            adapter.getRemoteDevice(normalizeAddress(address))
+                            adapter.getRemoteDevice(connectAddress)
                         } catch (e: IllegalArgumentException) {
                             throw TempivoSensorException(
                                 TempivoSensorException.Code.CONNECT_FAILED,
@@ -198,6 +229,7 @@ internal object EfentoRawConfigTransfer {
                                 e,
                             )
                         }
+                    connectedAddress = connectAddress
                     handler.post {
                         val g =
                             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
@@ -215,18 +247,49 @@ internal object EfentoRawConfigTransfer {
 
             val ok = latch.await(timeoutMs, TimeUnit.MILLISECONDS)
             if (!ok) {
-                fail(TempivoSensorException(TempivoSensorException.Code.UNKNOWN, "Raw config BLE timeout."))
+                fail(
+                    TempivoSensorException(
+                        TempivoSensorException.Code.UNKNOWN,
+                        "Raw config BLE timeout (no GATT response).",
+                    ),
+                )
                 latch.await(500, TimeUnit.MILLISECONDS)
             }
             val result =
                 resultRef.get()
-                    ?: throw TempivoSensorException(TempivoSensorException.Code.UNKNOWN, "Raw config BLE timeout.")
+                    ?: throw TempivoSensorException(
+                        TempivoSensorException.Code.UNKNOWN,
+                        "Raw config BLE timeout (no GATT response).",
+                    )
             return result.getOrThrow()
         }
 
+        private fun requestMtuThenAdvance(g: BluetoothGatt) {
+            // Kept for callers: at most one MTU request per connection (Android 14+ ignores more).
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && !mtuRequested) {
+                mtuRequested = true
+                awaitingMtu = true
+                val ok = runCatching { g.requestMtu(517) }.getOrDefault(false)
+                if (ok) {
+                    handler.postDelayed({
+                        synchronized(lock) {
+                            if (!finished && awaitingMtu) {
+                                awaitingMtu = false
+                                advance()
+                            }
+                        }
+                    }, 1_500)
+                    return
+                }
+                awaitingMtu = false
+            }
+            advance()
+        }
+
         private fun advance() {
             synchronized(lock) {
                 if (finished) return
+                if (awaitingMtu) return
                 val g = gatt ?: return
                 val w = writeChar
                 val n = notifyChar
@@ -259,21 +322,10 @@ internal object EfentoRawConfigTransfer {
                     ByteArray(0)
                 }
             val frame = buildCommandFrame(bluetoothMac, cmd, payload)
-            val max = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-                // Typical ATT payload after MTU negotiation; fall back conservatively.
-                512
-            } else {
-                20
-            }
-            if (frame.size > max) {
-                fail(
-                    TempivoSensorException(
-                        TempivoSensorException.Code.INVALID_CONFIG,
-                        "Config frame is ${frame.size} B but this link accepts $max B per write.",
-                    ),
-                )
-                return
-            }
+            // Never gate on negotiatedMtu. This HC7 answers MTU 23 on Android (even when we
+            // request 517; Android 14+ also ignores later requestMtu on the same link).
+            // WRITE_TYPE_DEFAULT lets the stack use ATT Prepare Write / Execute (long write)
+            // for frames larger than ATT payload, which is what set (0x0D) needs (~237 B).
             write.writeType = BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                 g.writeCharacteristic(write, frame, BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT)
@@ -283,7 +335,13 @@ internal object EfentoRawConfigTransfer {
                 @Suppress("DEPRECATION")
                 g.writeCharacteristic(write)
             }
+            // Do not read yet: long writes (237 B at MTU 23) finish asynchronously.
+            // onCharacteristicWrite schedules the follow-up read / assemble.
+        }
+
+        private fun afterCommandWriteAck() {
             val token = commandToken
+            val delayMs = if (writeProto != null) 200L else 100L
             handler.postDelayed({
                 synchronized(lock) {
                     if (finished || commandToken != token) return@synchronized
@@ -296,19 +354,19 @@ internal object EfentoRawConfigTransfer {
                         gg.readCharacteristic(w)
                     }
                 }
-            }, 350)
+            }, delayMs)
             if (writeProto != null) {
                 handler.postDelayed({
                     synchronized(lock) {
                         if (commandToken == token) finishWriteIfReady()
                     }
-                }, 800)
+                }, 1_500)
             } else {
                 handler.postDelayed({
                     synchronized(lock) {
                         if (commandToken == token) tryAssemble()
                     }
-                }, 1_000)
+                }, 1_200)
             }
         }
 
@@ -330,26 +388,63 @@ internal object EfentoRawConfigTransfer {
             object : BluetoothGattCallback() {
                 override fun onConnectionStateChange(g: BluetoothGatt, status: Int, newState: Int) {
                     if (newState == BluetoothProfile.STATE_CONNECTED) {
+                        synchronized(lock) {
+                            writeChar = null
+                            notifyChar = null
+                            discoveryStarted = false
+                            negotiatedMtu = 23
+                            mtuRequested = false
+                            awaitingMtu = false
+                        }
                         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-                            g.requestMtu(517)
-                        } else {
-                            synchronized(lock) {
-                                writeChar = null
-                                notifyChar = null
-                                discoveryStarted = false
+                            runCatching {
+                                g.requestConnectionPriority(BluetoothGatt.CONNECTION_PRIORITY_HIGH)
                             }
-                            advance()
                         }
+                        // Delay after connect before the first (and only) requestMtu so the host
+                        // controller can stabilize the ACL link (typical guidance: 300–600 ms).
+                        // Android 14+ often applies ~517 on that first request and ignores later ones.
+                        // Peripheral may still answer 23; set then relies on ATT long write, not a
+                        // hardcoded 20/185 B gate. Max single ATT PDU is negotiatedMtu - 3 (≤514).
+                        awaitingMtu = true
+                        handler.postDelayed({
+                            synchronized(lock) {
+                                if (finished || gatt !== g) return@synchronized
+                                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && !mtuRequested) {
+                                    mtuRequested = true
+                                    val ok = runCatching { g.requestMtu(517) }.getOrDefault(false)
+                                    if (ok) {
+                                        handler.postDelayed({
+                                            synchronized(lock) {
+                                                if (!finished && awaitingMtu) {
+                                                    awaitingMtu = false
+                                                    advance()
+                                                }
+                                            }
+                                        }, 1_500)
+                                        return@synchronized
+                                    }
+                                }
+                                awaitingMtu = false
+                                advance()
+                            }
+                        }, 600)
                     } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
                         synchronized(lock) {
                             writeChar = null
                             notifyChar = null
                             discoveryStarted = false
                             if (!finished) {
+                                val msg =
+                                    if (status == 133) {
+                                        "Config GATT connect failed (status 133). Retrying."
+                                    } else {
+                                        "Sensor dropped the config link."
+                                    }
                                 fail(
                                     TempivoSensorException(
                                         TempivoSensorException.Code.CONNECT_FAILED,
-                                        "Sensor dropped the config link.",
+                                        msg,
                                     ),
                                 )
                             }
@@ -359,10 +454,12 @@ internal object EfentoRawConfigTransfer {
 
                 override fun onMtuChanged(g: BluetoothGatt, mtu: Int, status: Int) {
                     synchronized(lock) {
-                        writeChar = null
-                        notifyChar = null
-                        discoveryStarted = false
+                        if (status == BluetoothGatt.GATT_SUCCESS && mtu > 0) {
+                            negotiatedMtu = mtu
+                        }
+                        awaitingMtu = false
                     }
+                    // Start or continue discovery / command after MTU.
                     advance()
                 }
 
@@ -402,6 +499,12 @@ internal object EfentoRawConfigTransfer {
                         notifyChar = notify
                     }
                     g.setCharacteristicNotification(notify, true)
+                    // Write char may also notify the start response on some FW.
+                    if ((write.properties and BluetoothGattCharacteristic.PROPERTY_NOTIFY) != 0 ||
+                        (write.properties and BluetoothGattCharacteristic.PROPERTY_INDICATE) != 0
+                    ) {
+                        g.setCharacteristicNotification(write, true)
+                    }
                     val cccd = notify.getDescriptor(CCCD)
                     if (cccd != null) {
                         val enable = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
@@ -427,6 +530,8 @@ internal object EfentoRawConfigTransfer {
                         fail(TempivoSensorException(TempivoSensorException.Code.UNKNOWN, "Notify enable failed."))
                         return
                     }
+                    // Do not call requestMtu again here. Android 14+ ignores subsequent MTU
+                    // requests on the same connection; HC7 often stays at 23 anyway.
                     advance()
                 }
 
@@ -437,7 +542,9 @@ internal object EfentoRawConfigTransfer {
                 ) {
                     if (status != BluetoothGatt.GATT_SUCCESS) {
                         fail(TempivoSensorException(TempivoSensorException.Code.UNKNOWN, "Config write failed ($status)."))
+                        return
                     }
+                    afterCommandWriteAck()
                 }
 
                 @Deprecated("Deprecated in Java")
@@ -486,7 +593,8 @@ internal object EfentoRawConfigTransfer {
                 if (finished || value.isEmpty()) return
                 val writeUuid = writeChar?.uuid
                 val notifyUuid = notifyChar?.uuid
-                if (uuid == writeUuid && !fromNotify) {
+                // iOS accepts start response on the write characteristic for both read and notify.
+                if (uuid == writeUuid) {
                     startResponse = value
                     if (writeProto != null) finishWriteIfReady()
                     return

package/android-aar/library/src/main/java/com/tempivo/sensor/beacon/TempivoSensorSession.kt

@@ -202,14 +202,8 @@ class TempivoSensorSession(
         if (lastMac.isEmpty() || lastPin.isEmpty()) {
             throw TempivoSensorException(TempivoSensorException.Code.NOT_CONNECTED, "Not connected. Scan and connect first.")
         }
-        // Prefer scan/SDK device id when it looks like a BLE address; else MAC.
-        val id = lastDeviceId.trim()
-        val idHex = id.replace(":", "").replace("-", "")
-        return if (idHex.length == 12 && idHex.all { it.isDigit() || it in 'a'..'f' || it in 'A'..'F' }) {
-            id
-        } else {
-            lastMac
-        }
+        // Always the public Bluetooth MAC for raw GATT (CRC + connectGatt).
+        return lastMac
     }
 
     private suspend fun <T> withRawConfigLink(body: suspend (String) -> T): T {
@@ -230,7 +224,7 @@ class TempivoSensorSession(
                 session = null
                 sdkConnected = false
             }
-            if (didDisconnect) delay(1_000)
+            if (didDisconnect) delay(1_500)
         }
     }
 

package/dist/proto/partner-to-proto.d.ts

@@ -4,6 +4,26 @@
  */
 import type { TempivoSensorConfiguration } from '../session-types.js';
 import { type ProtoConfigObject } from './decode-proto-config.js';
+/**
+ * Fields carried from the device baseline into a set (0x0D).
+ *
+ * A device read returns the full config, including server endpoints, APN, cloud token and
+ * telemetry. Echoing all of that back exceeds the single-write ATT limit (~512 B) and would
+ * rewrite cellular settings we never intended to touch, so only rules-related fields are kept.
+ */
+export declare const WRITE_BASELINE_FIELDS: readonly ["serialNumber", "channelTypes", "measurementPeriodBase", "measurementPeriodFactor", "transmissionInterval"];
+/**
+ * ProtoConfig keys that must never appear on a partner alarm-rule write.
+ * Writing these can break cellular uplink (device looks "offline" in Tempivo).
+ */
+export declare const FORBIDDEN_PARTNER_WRITE_FIELDS: readonly ["dataServerIp", "dataServerPort", "updateServerIp", "updateServerPortUdp", "updateServerPortCoap", "apn", "apnUsername", "apnPassword", "cloudToken", "cloudTokenConfig", "cloudTokenCoapOption", "dataEndpoint", "configurationEndpoint", "deviceInfoEndpoint", "timeEndpoint", "extendedConfigurationEndpoint", "dnsServerIp", "networkKey", "encryptionKey", "plmnSelection", "modemBandsMask", "disableModemRequest", "cellularConfigParams", "networkSearch", "networkTroubleshooting"];
+/**
+ * Fail closed if a ProtoConfig object still carries cellular / server fields.
+ * Call before encoding a partner set (0x0D).
+ */
+export declare function assertSafePartnerProtoWrite(cfg: ProtoConfigObject, options?: {
+    allowExtraKeys?: boolean;
+}): void;
 /** Patch partner alerts/schedule/intervals onto a baseline ProtoConfig object. */
 export declare function applyPartnerConfigToProtoObject(baseline: ProtoConfigObject, partner: TempivoSensorConfiguration): ProtoConfigObject;
 export declare function encodeProtoConfigObject(cfg: ProtoConfigObject): Uint8Array;

package/dist/proto/partner-to-proto.js

@@ -1,4 +1,4 @@
-import { decodeProtoConfigBase64 } from './decode-proto-config.js';
+import { decodeProtoConfigBase64, decodeProtoConfigBytes, } from './decode-proto-config.js';
 import protobuf from 'protobufjs/light.js';
 import descriptor from './efento-protobuf-descriptor.js';
 const root = protobuf.Root.fromJSON(descriptor);
@@ -150,13 +150,80 @@ function disabledCalendars() {
  * telemetry. Echoing all of that back exceeds the single-write ATT limit (~512 B) and would
  * rewrite cellular settings we never intended to touch, so only rules-related fields are kept.
  */
-const WRITE_BASELINE_FIELDS = [
+export const WRITE_BASELINE_FIELDS = [
     'serialNumber',
     'channelTypes',
     'measurementPeriodBase',
     'measurementPeriodFactor',
     'transmissionInterval',
 ];
+/**
+ * ProtoConfig keys that must never appear on a partner alarm-rule write.
+ * Writing these can break cellular uplink (device looks "offline" in Tempivo).
+ */
+export const FORBIDDEN_PARTNER_WRITE_FIELDS = [
+    'dataServerIp',
+    'dataServerPort',
+    'updateServerIp',
+    'updateServerPortUdp',
+    'updateServerPortCoap',
+    'apn',
+    'apnUsername',
+    'apnPassword',
+    'cloudToken',
+    'cloudTokenConfig',
+    'cloudTokenCoapOption',
+    'dataEndpoint',
+    'configurationEndpoint',
+    'deviceInfoEndpoint',
+    'timeEndpoint',
+    'extendedConfigurationEndpoint',
+    'dnsServerIp',
+    'networkKey',
+    'encryptionKey',
+    'plmnSelection',
+    'modemBandsMask',
+    'disableModemRequest',
+    'cellularConfigParams',
+    'networkSearch',
+    'networkTroubleshooting',
+];
+const ALLOWED_WRITE_KEYS = new Set([
+    ...WRITE_BASELINE_FIELDS,
+    'rules',
+    'calendars',
+]);
+function isPresentProtoValue(value) {
+    if (value == null)
+        return false;
+    if (typeof value === 'string')
+        return value.length > 0;
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (typeof value === 'boolean')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (typeof value === 'object')
+        return Object.keys(value).length > 0;
+    return true;
+}
+/**
+ * Fail closed if a ProtoConfig object still carries cellular / server fields.
+ * Call before encoding a partner set (0x0D).
+ */
+export function assertSafePartnerProtoWrite(cfg, options = {}) {
+    const forbiddenHit = FORBIDDEN_PARTNER_WRITE_FIELDS.filter((field) => isPresentProtoValue(cfg[field]));
+    if (forbiddenHit.length > 0) {
+        throw new Error(`Partner BLE set must not write cellular/server fields: ${forbiddenHit.join(', ')}.`);
+    }
+    if (options.allowExtraKeys)
+        return;
+    const unknown = Object.keys(cfg).filter((key) => isPresentProtoValue(cfg[key]) && !ALLOWED_WRITE_KEYS.has(key));
+    if (unknown.length > 0) {
+        throw new Error(`Partner BLE set includes unsupported ProtoConfig fields: ${unknown.join(', ')}.`);
+    }
+}
 /** Patch partner alerts/schedule/intervals onto a baseline ProtoConfig object. */
 export function applyPartnerConfigToProtoObject(baseline, partner) {
     const { rules, mask } = compileAlerts(partner.temperatureAlerts ?? []);
@@ -179,6 +246,7 @@ export function applyPartnerConfigToProtoObject(baseline, partner) {
     if (partner.transmissionIntervalSeconds != null && partner.transmissionIntervalSeconds > 0) {
         out.transmissionInterval = partner.transmissionIntervalSeconds;
     }
+    assertSafePartnerProtoWrite(out);
     return out;
 }
 export function encodeProtoConfigObject(cfg) {
@@ -207,5 +275,8 @@ export function bytesToBase64(bytes) {
 export function partnerConfigToProtoBase64(partner, baselineProtoBase64) {
     const baseline = decodeProtoConfigBase64(baselineProtoBase64);
     const next = applyPartnerConfigToProtoObject(baseline, partner);
-    return bytesToBase64(encodeProtoConfigObject(next));
+    const encoded = encodeProtoConfigObject(next);
+    // After wire encode, only re-check cellular/server keys (protobuf may add defaults).
+    assertSafePartnerProtoWrite(decodeProtoConfigBytes(encoded), { allowExtraKeys: true });
+    return bytesToBase64(encoded);
 }

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

@@ -8,7 +8,7 @@
 			<key>BinaryPath</key>
 			<string>TempivoSensorBridge.framework/TempivoSensorBridge</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64-simulator</string>
 			<key>LibraryPath</key>
 			<string>TempivoSensorBridge.framework</string>
 			<key>SupportedArchitectures</key>
@@ -17,12 +17,14 @@
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>TempivoSensorBridge.framework/TempivoSensorBridge</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>TempivoSensorBridge.framework</string>
 			<key>SupportedArchitectures</key>
@@ -31,8 +33,6 @@
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tempivo/sensor-beacon",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "Tempivo sensor BLE SDK. Native scan and GATT for Expo, React Native, Android, and iOS. Node helpers decode advertisements and parse QR or config (no radio).",
   "homepage": "https://app.tempivo.com/integrations",
   "repository": {