@tempivo/sensor-beacon 1.1.1 → 1.1.2

package/CHANGELOG.md

@@ -6,6 +6,20 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.1.2] - 2026-09-05
+
+### Fixed
+
+- BLE get: `schedule: { always: true }` no longer reads back as `weekdays: [6]`.
+- BLE set: dual ambient + probe ranges with `transmitOnReturn` keep alerts on get (interleaved OR after each pair).
+- Native compile fail-closed on bad/missing alert fields or full slots (no silent drop).
+- Post-set readback requires alert count ≥ written count.
+- iOS parse aligned with Android/TS (required thresholds, schedule fields, slot budget).
+
+### Changed
+
+- README: range + `transmitOnReturn` uses **3** slots; weekday BLE get caveat.
+
 ## [1.1.1] - 2026-09-03
 
 ### Changed

package/README.md

@@ -263,7 +263,9 @@ When **both** are set on write, uplink must be at most **60×** the measurement
 
 Use `parseSensorConfigurationJson` to validate before write. Use `parseSensorConfigurationFromDevice` / `parseSensorConfigurationFromDeviceJson` when parsing a **readback** from the device (relaxed interval rules). For `GET /devices/config-profiles/{slug}`, use `configurationFromApiProfile(response.profile)` or pass the `{ profile }` envelope directly to `setConfigurationJson`.
 
-**Alert slot budget:** the device has **12** rule slots. A `range` with default `transmitOnReturn: true` uses **two** slots (breach + return). Up to **4** such ranges, or more min/max alerts if you disable `transmitOnReturn` on ranges.
+**Alert slot budget:** the device has **12** rule slots. A `range` with default `transmitOnReturn: true` uses **three** slots (`low` + `high` + OR). Up to **4** such ranges. A lone `min`/`max` uses one; with return on a range disabled, a range uses two.
+
+**Weekday schedules** (`Mon–Fri`, etc.): BLE **get** may not round-trip weekdays on current partner firmware (day-mask decode). Prefer `{ "always": true }` when possible. After set, if get looks wrong (e.g. only Sunday), trust what you wrote.
 
 **Each `temperatureAlerts[]` item**
 

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

@@ -16,7 +16,8 @@ import pl.efento.mobile.bluetooth.model.sensor.TriggeringMode
 
 /**
  * Compile Cellular API `temperatureAlerts` + `schedule` into device rules.
- * Range + `transmitOnReturn` uses the same OR layout as POST /devices/config-profiles.
+ * Range + `transmitOnReturn` uses an OR slot immediately after each low/high pair
+ * (same layout as a single range with return; required for dual-range BLE writes).
  */
 internal object PartnerBleRules {
     fun compile(cfg: TempivoSensorConfiguration): Pair<List<Rule>, List<RuleCalendar>> {
@@ -24,30 +25,30 @@ internal object PartnerBleRules {
             Rule(i + 1, emptySet(), DisabledCondition, Action.NO_ACTION)
         }
         val used = BooleanArray(12)
-        val returnLowSlots = mutableListOf<Int>()
 
         for (alert in cfg.temperatureAlerts) {
             val channel = if (alert.channel == "probe") 3 else 1
             val hyst = alert.hysteresisC ?: 1.0
             when (alert.type) {
                 "min" -> {
-                    val slot = findFree(used) ?: continue
-                    val t = alert.minC ?: continue
+                    val slot = findFree(used) ?: throw compileFail("Not enough free alarm rule slots.")
+                    val t = alert.minC ?: throw compileFail("min alert is missing minC.")
                     val action = if (alert.transmitOnBreach) Action.TRIGGER_TRANSMISSION_WITH_ACK else Action.NO_ACTION
                     putThreshold(rules, slot, channel, low = true, t, hyst, action)
                     used[slot] = true
                 }
                 "max" -> {
-                    val slot = findFree(used) ?: continue
-                    val t = alert.maxC ?: continue
+                    val slot = findFree(used) ?: throw compileFail("Not enough free alarm rule slots.")
+                    val t = alert.maxC ?: throw compileFail("max alert is missing maxC.")
                     val action = if (alert.transmitOnBreach) Action.TRIGGER_TRANSMISSION_WITH_ACK else Action.NO_ACTION
                     putThreshold(rules, slot, channel, low = false, t, hyst, action)
                     used[slot] = true
                 }
                 "range" -> {
-                    val low = alert.lowC ?: continue
-                    val high = alert.highC ?: continue
-                    val pair = findPair(used) ?: continue
+                    val low = alert.lowC ?: throw compileFail("range alert is missing lowC.")
+                    val high = alert.highC ?: throw compileFail("range alert is missing highC.")
+                    val pair = findPair(used)
+                        ?: throw compileFail("Not enough free alarm rule slots for another range (need two consecutive slots).")
                     val ret = alert.transmitOnReturn
                     val action =
                         when {
@@ -59,31 +60,19 @@ internal object PartnerBleRules {
                     putThreshold(rules, pair + 1, channel, low = false, high, hyst, action)
                     used[pair] = true
                     used[pair + 1] = true
-                    if (ret) returnLowSlots.add(pair)
+                    // Place OR immediately after each pair (low, high, OR, …).
+                    // Batching all pairs then ORs at the end clears dual-range configs on device.
+                    if (ret) {
+                        val logicSlot = findFree(used)
+                            ?: throw compileFail("Not enough free alarm rule slots for transmit-on-return (OR logic).")
+                        putReturnOr(rules, logicSlot, pair)
+                        used[logicSlot] = true
+                    }
                 }
+                else -> throw compileFail("Unsupported temperature alert type: ${alert.type}.")
             }
         }
 
-        for (lowSlot in returnLowSlots) {
-            val logicSlot = findFree(used) ?: break
-            rules[logicSlot] =
-                Rule(
-                    logicSlot + 1,
-                    emptySet(),
-                    LogicOperatorCondition(
-                        LogicOperatorConditionParameters(
-                            LogicOperator.OR,
-                            setOf(lowSlot + 1, lowSlot + 2),
-                            emptySet(),
-                            0,
-                            0,
-                        ),
-                    ),
-                    Action.TRIGGER_TRANSMISSION_WITH_ACK,
-                )
-            used[logicSlot] = true
-        }
-
         val active = rules.filter { it.condition !is DisabledCondition }.map { it.id }.toSet()
         val calendars = MutableList(6) { i ->
             RuleCalendar(i + 1, emptySet(), RuleCalendar.Type.Disabled)
@@ -129,6 +118,17 @@ internal object PartnerBleRules {
             )
             used[i] = true
             used[i + 1] = true
+            if (hasReturn) {
+                for (j in 0 until 12) {
+                    val c = padded[j].condition as? LogicOperatorCondition ?: continue
+                    val p = c.conditionParameters
+                    if (p.logicOperator != LogicOperator.OR) continue
+                    if (p.selectedRules == setOf(i + 1, i + 2)) {
+                        used[j] = true
+                        break
+                    }
+                }
+            }
         }
 
         for (i in 0 until 12) {
@@ -200,6 +200,9 @@ internal object PartnerBleRules {
             else -> null
         }
 
+    private fun compileFail(message: String): Nothing =
+        throw TempivoSensorException(TempivoSensorException.Code.INVALID_CONFIG, message)
+
     private fun findPair(used: BooleanArray): Int? {
         for (i in 0..10) {
             if (!used[i] && !used[i + 1]) return i
@@ -221,7 +224,7 @@ internal object PartnerBleRules {
         hyst: Double,
         action: Action,
     ) {
-        if (slot !in 0..11) return
+        if (slot !in 0..11) throw compileFail("Alarm rule slot out of range: $slot.")
         val params =
             TemperatureLowHighThresholdConditionParameters(
                 threshold,
@@ -233,22 +236,41 @@ internal object PartnerBleRules {
         rules[slot] = Rule(slot + 1, setOf(channel), condition, action)
     }
 
+    private fun putReturnOr(rules: MutableList<Rule>, logicSlot: Int, lowSlot: Int) {
+        rules[logicSlot] =
+            Rule(
+                logicSlot + 1,
+                emptySet(),
+                LogicOperatorCondition(
+                    LogicOperatorConditionParameters(
+                        LogicOperator.OR,
+                        setOf(lowSlot + 1, lowSlot + 2),
+                        emptySet(),
+                        0,
+                        0,
+                    ),
+                ),
+                Action.TRIGGER_TRANSMISSION_WITH_ACK,
+            )
+    }
+
     private fun decompileSchedule(calendars: List<RuleCalendar>?): TempivoSchedule {
         val weekly = calendars.orEmpty().map { it.type }.filterIsInstance<RuleCalendar.Type.Weekly>().firstOrNull()
             ?: return TempivoSchedule(always = true)
         val days = weekly.days.map { dayToPartnerIndex(it) }.sorted()
-        val always = days.size == 7 && weekly.fromTime == 0 && weekly.toTime >= 1439
-        return if (always) {
-            TempivoSchedule(always = true)
-        } else {
-            TempivoSchedule(
-                always = false,
-                weekdays = days,
-                from = TempivoSensorProfile.hhmmFromMinutes(weekly.fromTime),
-                to = TempivoSensorProfile.hhmmFromMinutes(weekly.toTime),
-                utcOffsetMinutes = weekly.timezoneOffset,
-            )
+        val fullDay = weekly.fromTime == 0 && weekly.toTime >= 1439
+        // Efento BLE SDK day-mask decode keeps only Sunday (`(mask & bit) != 1`).
+        // always:true (all days, 00:00–23:59) therefore reads back as weekdays [6].
+        if (fullDay && (days.size == 7 || days.isEmpty() || days == listOf(6))) {
+            return TempivoSchedule(always = true)
         }
+        return TempivoSchedule(
+            always = false,
+            weekdays = days,
+            from = TempivoSensorProfile.hhmmFromMinutes(weekly.fromTime),
+            to = TempivoSensorProfile.hhmmFromMinutes(weekly.toTime),
+            utcOffsetMinutes = weekly.timezoneOffset,
+        )
     }
 
     private fun weeklyType(schedule: TempivoSchedule): RuleCalendar.Type {

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

@@ -88,6 +88,15 @@ internal object SensorBleRuntime {
             next = next.copy(transmissionInterval = TransmissionInterval(sec))
         }
         session.connection.commands.setConfiguration(next) { }
+        if (cfg.temperatureAlerts.isNotEmpty()) {
+            val verify = decompile(modernGetConfiguration(session.connection))
+            if (verify.temperatureAlerts.size < cfg.temperatureAlerts.size) {
+                throw TempivoSensorException(
+                    TempivoSensorException.Code.UNKNOWN,
+                    "Device rejected alarm rules (readback ${verify.temperatureAlerts.size}/${cfg.temperatureAlerts.size}).",
+                )
+            }
+        }
     }
 
     suspend fun triggerTransmission(session: Session): TempivoSensorSession.TriggerResult {

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

@@ -68,6 +68,7 @@ object TempivoSensorProfile {
             val item = arr.optJSONObject(i) ?: throw invalid("temperatureAlerts[$i] must be an object.")
             alerts.add(parseAlert(item, i))
         }
+        assertAlertSlotBudget(alerts)
         val intervals = parseOptionalIntervals(body)
         return TempivoSensorConfiguration(
             alerts,
@@ -111,6 +112,33 @@ object TempivoSensorProfile {
         return root.toString()
     }
 
+
+    private fun assertAlertSlotBudget(alerts: List<TempivoTemperatureAlert>) {
+        val used = BooleanArray(12)
+        fun findPair(): Int? {
+            for (i in 0..10) if (!used[i] && !used[i + 1]) return i
+            return null
+        }
+        fun findFree(): Int? {
+            for (i in 0 until 12) if (!used[i]) return i
+            return null
+        }
+        for (alert in alerts) {
+            if (alert.type == "range") {
+                val pair = findPair() ?: throw invalid("Not enough free alarm rule slots for another range (need two consecutive slots).")
+                used[pair] = true
+                used[pair + 1] = true
+                if (alert.transmitOnReturn) {
+                    val logic = findFree() ?: throw invalid("Not enough free alarm rule slots for transmit-on-return (OR logic).")
+                    used[logic] = true
+                }
+            } else {
+                val slot = findFree() ?: throw invalid("Not enough free alarm rule slots.")
+                used[slot] = true
+            }
+        }
+    }
+
     private fun parseOptionalIntervals(body: JSONObject): Pair<Double?, Int?> {
         var measurement: Double? = null
         var transmission: Int? = null

package/dist/native-helpers.js

@@ -1,4 +1,5 @@
 import { TempivoSensorError } from './errors.js';
+import { pickPartnerConfigurationJson } from './profile.js';
 const SENSOR_CODES = [
     'invalidPin',
     'invalidQr',
@@ -22,7 +23,8 @@ export function qrToConnectJson(qr) {
     return JSON.stringify(body);
 }
 export function configToJson(config) {
-    return typeof config === 'string' ? config : JSON.stringify(config);
+    // Always validate partner shape + slot budget before native setConfiguration.
+    return pickPartnerConfigurationJson(typeof config === 'string' ? config : JSON.stringify(config));
 }
 function isSensorCode(value) {
     return !!value && SENSOR_CODES.includes(value);

package/dist/profile.js

@@ -39,10 +39,12 @@ function findFreeSlot(used) {
     }
     return null;
 }
-/** Same 12-slot layout as Cellular API, including one extra slot per range with transmitOnReturn. */
+/**
+ * 12-slot BLE layout: each range with transmitOnReturn uses low+high then an OR
+ * slot immediately after (same order native compile writes).
+ */
 function assertAlertSlotBudget(alerts) {
     const used = Array(12).fill(false);
-    const returnLowSlots = [];
     for (const alert of alerts) {
         if (alert.type === 'range') {
             const pair = findPairStart(used);
@@ -51,8 +53,13 @@ function assertAlertSlotBudget(alerts) {
             }
             used[pair] = true;
             used[pair + 1] = true;
-            if (alert.transmitOnReturn)
-                returnLowSlots.push(pair);
+            if (alert.transmitOnReturn) {
+                const logic = findFreeSlot(used);
+                if (logic === null) {
+                    throw new TempivoSensorError('invalidConfig', 'Not enough free alarm rule slots for transmit-on-return (OR logic).');
+                }
+                used[logic] = true;
+            }
         }
         else {
             const slot = findFreeSlot(used);
@@ -62,15 +69,27 @@ function assertAlertSlotBudget(alerts) {
             used[slot] = true;
         }
     }
-    for (const _low of returnLowSlots) {
-        const slot = findFreeSlot(used);
-        if (slot === null) {
-            throw new TempivoSensorError('invalidConfig', 'Not enough free alarm rule slots for transmit-on-return (OR logic).');
-        }
-        used[slot] = true;
+}
+/**
+ * Efento BLE SDK (2.3/2.4) day-mask decode compares `(mask & bit) != 1`, so only
+ * Sunday (bit 0) survives. Writing `schedule: { always: true }` (all 7 days,
+ * 00:00–23:59) therefore reads back as `weekdays: [6]`. Normalize that shape on
+ * device read so get matches set.
+ */
+function normalizeScheduleFromDevice(schedule) {
+    if ('always' in schedule && schedule.always)
+        return schedule;
+    if (!('weekdays' in schedule))
+        return schedule;
+    if (schedule.from !== '00:00' || schedule.to !== '23:59')
+        return schedule;
+    const days = [...new Set(schedule.weekdays)].sort((a, b) => a - b);
+    if (days.length === 7 || days.length === 0 || (days.length === 1 && days[0] === 6)) {
+        return { always: true };
     }
+    return schedule;
 }
-function parseSchedule(raw) {
+function parseSchedule(raw, fromDevice = false) {
     if (raw == null)
         return { always: true };
     if (!isRecord(raw)) {
@@ -99,7 +118,8 @@ function parseSchedule(raw) {
     if (utc === undefined || !Number.isInteger(utc)) {
         throw new TempivoSensorError('invalidConfig', 'schedule.utcOffsetMinutes is required.');
     }
-    return { weekdays: days, from, to, utcOffsetMinutes: utc };
+    const schedule = { weekdays: days, from, to, utcOffsetMinutes: utc };
+    return fromDevice ? normalizeScheduleFromDevice(schedule) : schedule;
 }
 function parseAlert(item, index) {
     if (!isRecord(item)) {
@@ -249,7 +269,7 @@ function parseSensorConfigurationBody(body, options = {}) {
     const intervals = parseOptionalIntervals(body, options);
     return {
         temperatureAlerts,
-        schedule: parseSchedule(body.schedule),
+        schedule: parseSchedule(body.schedule, options.fromDevice === true),
         ...intervals,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tempivo/sensor-beacon",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "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": {