@tempivo/sensor-beacon 0.4.3 → 0.4.7

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

@@ -35,6 +35,8 @@ data class TempivoSensorBeaconDevice(
     val bluetoothMacAddress: String,
     val serialNumber: String,
     val rssi: Int,
+    /** HC7 when advertisement firmware is missing; else inferred from FW major. */
+    val model: String = SensorModelHint.DEFAULT_MODEL,
     val telemetry: TempivoSensorBeaconTelemetry?,
     val summary: String?,
 )

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

@@ -8,6 +8,8 @@ data class TempivoSensorQr(
     val pin: String,
     val model: String?,
     val bluetoothMac: String,
+    /** SDK `device.id` from scan when it differs from sticker serial. */
+    val deviceId: String? = null,
 )
 
 object TempivoSensorQrParser {
@@ -29,6 +31,15 @@ object TempivoSensorQrParser {
         }
     }
 
+    fun normalizeMac(value: String): String {
+        val trimmed = value.trim()
+        if (trimmed.contains(':')) {
+            val key = normalizeSerial(trimmed.replace(":", ""))
+            return bluetoothMacFromSerial(key)
+        }
+        return bluetoothMacFromSerial(trimmed)
+    }
+
     fun assertSupportedModel(model: String) {
         val m = model.trim().uppercase(Locale.US).replace("-", "")
         if (m == "HC5") {
@@ -62,11 +73,19 @@ object TempivoSensorQrParser {
         val model = rec.optString("model").trim().ifEmpty { DEFAULT_MODEL }
         assertSupportedModel(model)
         val hex = if (serial.length == 12) serial else serial.takeLast(12)
+        val macOverride =
+            sequenceOf("bluetoothMac", "bluetoothMacAddress", "mac")
+                .mapNotNull { key ->
+                    rec.optString(key).trim().takeIf { it.isNotEmpty() }
+                }
+                .firstOrNull()
+        val deviceId = rec.optString("deviceId").trim().ifEmpty { null }
         return TempivoSensorQr(
             serial = serial,
             pin = pin,
             model = model,
-            bluetoothMac = bluetoothMacFromSerial(hex),
+            bluetoothMac = macOverride?.let { normalizeMac(it) } ?: bluetoothMacFromSerial(hex),
+            deviceId = deviceId,
         )
     }
 

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

@@ -15,7 +15,6 @@ class TempivoSensorSession(
 ) {
     data class TriggerResult(
         val ok: Boolean,
-        val supported: Boolean,
     )
 
     private val application = context.applicationContext as android.app.Application
@@ -26,10 +25,16 @@ class TempivoSensorSession(
         serial: String,
         bluetoothMac: String,
         pin: String,
+        deviceId: String? = null,
     ) {
-        val pinInt =
-            pin.trim().toIntOrNull()
-                ?: throw TempivoSensorException(TempivoSensorException.Code.INVALID_PIN, "PIN must be numeric.")
+        val trimmedPin = pin.trim()
+        if (trimmedPin.isEmpty()) {
+            throw TempivoSensorException(TempivoSensorException.Code.INVALID_PIN, "PIN must be numeric.")
+        }
+        if (!trimmedPin.matches(Regex("^\\d+$"))) {
+            throw TempivoSensorException(TempivoSensorException.Code.INVALID_PIN, "PIN must be numeric.")
+        }
+        val resolvedDeviceId = deviceId?.trim()?.takeIf { it.isNotEmpty() } ?: serial
         try {
             mutex.withLock {
                 SensorBleRuntime.disconnect(session)
@@ -38,9 +43,9 @@ class TempivoSensorSession(
                     withContext(Dispatchers.Main) {
                         SensorBleRuntime.connect(
                             application = application,
-                            serial = TempivoSensorQrParser.normalizeSerial(serial),
+                            deviceId = resolvedDeviceId,
                             bluetoothMac = bluetoothMac,
-                            pin = pinInt,
+                            pin = trimmedPin,
                         )
                     }
             }
@@ -55,8 +60,12 @@ class TempivoSensorSession(
         }
     }
 
+    suspend fun connect(qr: TempivoSensorQr, deviceId: String, bluetoothMac: String) {
+        connect(qr.serial, bluetoothMac, qr.pin, deviceId)
+    }
+
     suspend fun connect(qr: TempivoSensorQr) {
-        connect(qr.serial, qr.bluetoothMac, qr.pin)
+        connect(qr.serial, qr.bluetoothMac, qr.pin, qr.deviceId)
     }
 
     suspend fun disconnect() {
@@ -92,6 +101,9 @@ class TempivoSensorSession(
         return runGatt { SensorBleRuntime.readCalibration(requireSession()) }
     }
 
+    fun connectBlocking(qr: TempivoSensorQr, deviceId: String, bluetoothMac: String) =
+        runBlocking { connect(qr, deviceId, bluetoothMac) }
+
     fun connectBlocking(qr: TempivoSensorQr) = runBlocking { connect(qr) }
 
     fun disconnectBlocking() = runBlocking { disconnect() }

package/dist/connect-helpers.d.ts

@@ -0,0 +1,52 @@
+import type { TempivoNativeMeasurement, TempivoSensorBeaconDevice } from './native-types.js';
+import type { TempivoSensorQr } from './session-types.js';
+/** Loose sticker QR parse (same shape as in-app `parseEfentoQrJson`). Returns null on invalid JSON. */
+export type ParsedSensorQrLoose = {
+    sn?: string;
+    pin?: string;
+    model?: string;
+    iccid?: string;
+};
+export type SensorStickerModel = 'HC5' | 'HC7';
+export type SensorBleConnectCredentials = {
+    resetCode?: number;
+    encryptionKey?: string;
+};
+/** PIN / reset code from sticker JSON (`pin` or `resetCode`, string or number). */
+export declare function pinFromSensorQrRecord(rec: Record<string, unknown>): string | undefined;
+/** Parse sticker QR JSON without throwing (invalid → null). */
+export declare function tryParseSensorQrJson(text: string): ParsedSensorQrLoose | null;
+/** Serial from QR scan payload (structured or raw JSON). 12 hex chars or null. */
+export declare function serialHexFromSensorQrScan(data: string | {
+    sn?: string;
+    raw?: string;
+} | null | undefined): string | null;
+/**
+ * True when QR serial is missing/incomplete, or matches selected BLE serial.
+ * False when both are 12-hex and differ (wrong sticker for selected device).
+ */
+export declare function sensorQrSerialMatchesSelected(qrSerialHex: string | null | undefined, selectedSerial: string | null | undefined): boolean;
+/** Normalize sticker `model` to HC5/HC7, or null if missing/unknown. */
+export declare function normalizeSensorStickerModel(model: string | undefined | null): SensorStickerModel | null;
+/**
+ * Map label PIN to native connect credentials (resetCode + encryptionKey for 5–6 digit codes).
+ * Same rules as Tempivo app `resolveEfentoBleConnectCredentialsFromPin`.
+ */
+export declare function resolveSensorBleConnectCredentialsFromPin(pinOrCode: string | undefined | null): SensorBleConnectCredentials;
+export declare function buildSensorQrConnectJson(parts: {
+    serial: string;
+    pin: string;
+    model?: string;
+    deviceId?: string;
+}): string;
+/** Build connect JSON from a parsed QR (strict) or loose scan result. */
+export declare function sensorQrConnectJsonFromLoose(loose: ParsedSensorQrLoose, deviceId?: string): string | null;
+type ScanDevicePick = Pick<TempivoSensorBeaconDevice, 'serialNumber' | 'deviceId' | 'bluetoothMacAddress' | 'model' | 'telemetry'>;
+/** Draft QR JSON from a scan row (uses device model / FW hint, keeps existing PIN if provided). */
+export declare function draftSensorQrConnectJsonFromScanDevice(device: ScanDevicePick, pin?: string): string | null;
+/** Merge scan `deviceId` / MAC from a selected row into a parsed QR for connect. */
+export declare function mergeScanTargetIntoSensorQr(qr: TempivoSensorQr, device: ScanDevicePick | null | undefined): TempivoSensorQr;
+/** Parse QR text and attach scan target (deviceId, MAC) when a row is selected. */
+export declare function parseSensorQrForConnect(qrText: string, selectedDevice?: ScanDevicePick | null): TempivoSensorQr;
+export declare function formatSensorReadingLine(reading: Pick<TempivoNativeMeasurement, 'typeHex' | 'text'>): string;
+export {};

package/dist/connect-helpers.js

@@ -0,0 +1,153 @@
+import { sensorModelFromFirmware } from './model.js';
+import { DEFAULT_SENSOR_MODEL, normalizeSensorSerial, parseSensorQrJson } from './qr.js';
+/** PIN / reset code from sticker JSON (`pin` or `resetCode`, string or number). */
+export function pinFromSensorQrRecord(rec) {
+    const raw = rec.pin ?? rec.resetCode;
+    if (typeof raw === 'string') {
+        const t = raw.trim();
+        return t.length > 0 ? t : undefined;
+    }
+    if (typeof raw === 'number' && Number.isFinite(raw)) {
+        return String(Math.trunc(raw));
+    }
+    return undefined;
+}
+function serialFromQrRecord(rec) {
+    if (typeof rec.sn === 'string')
+        return rec.sn;
+    if (typeof rec.sn === 'number' && Number.isFinite(rec.sn))
+        return String(Math.trunc(rec.sn));
+    return undefined;
+}
+/** Parse sticker QR JSON without throwing (invalid → null). */
+export function tryParseSensorQrJson(text) {
+    try {
+        const o = JSON.parse(text.trim());
+        if (o === null || typeof o !== 'object' || Array.isArray(o))
+            return null;
+        const rec = o;
+        return {
+            sn: serialFromQrRecord(rec),
+            pin: pinFromSensorQrRecord(rec),
+            model: typeof rec.model === 'string' ? rec.model : undefined,
+            iccid: typeof rec.iccid === 'string' ? rec.iccid : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Serial from QR scan payload (structured or raw JSON). 12 hex chars or null. */
+export function serialHexFromSensorQrScan(data) {
+    if (data == null)
+        return null;
+    let sn;
+    if (typeof data === 'string') {
+        sn = tryParseSensorQrJson(data)?.sn;
+    }
+    else {
+        sn = data.sn?.trim() || (typeof data.raw === 'string' ? tryParseSensorQrJson(data.raw)?.sn : undefined);
+    }
+    if (!sn)
+        return null;
+    const hex = normalizeSensorSerial(sn);
+    return hex.length === 12 ? hex : null;
+}
+/**
+ * True when QR serial is missing/incomplete, or matches selected BLE serial.
+ * False when both are 12-hex and differ (wrong sticker for selected device).
+ */
+export function sensorQrSerialMatchesSelected(qrSerialHex, selectedSerial) {
+    const qr = normalizeSensorSerial(qrSerialHex ?? '');
+    const sel = normalizeSensorSerial(selectedSerial ?? '');
+    if (qr.length !== 12 || sel.length !== 12)
+        return true;
+    return qr === sel;
+}
+/** Normalize sticker `model` to HC5/HC7, or null if missing/unknown. */
+export function normalizeSensorStickerModel(model) {
+    if (model == null || model.trim() === '')
+        return null;
+    const m = model.trim().toUpperCase().replace(/-/g, '');
+    if (m === 'HC5')
+        return 'HC5';
+    if (m === 'HC7')
+        return 'HC7';
+    return null;
+}
+/**
+ * Map label PIN to native connect credentials (resetCode + encryptionKey for 5–6 digit codes).
+ * Same rules as Tempivo app `resolveEfentoBleConnectCredentialsFromPin`.
+ */
+export function resolveSensorBleConnectCredentialsFromPin(pinOrCode) {
+    const pin = pinOrCode?.trim() ?? '';
+    if (!pin)
+        return {};
+    if (!/^\d+$/.test(pin)) {
+        return { encryptionKey: pin };
+    }
+    const parsed = Number.parseInt(pin, 10);
+    if (Number.isNaN(parsed) || parsed < 0) {
+        return { encryptionKey: pin };
+    }
+    const cred = { resetCode: parsed };
+    if (pin.length > 4 || pin.startsWith('0')) {
+        cred.encryptionKey = pin;
+    }
+    return cred;
+}
+export function buildSensorQrConnectJson(parts) {
+    const body = {
+        sn: parts.serial,
+        pin: parts.pin,
+        model: parts.model ?? DEFAULT_SENSOR_MODEL,
+    };
+    if (parts.deviceId?.trim())
+        body.deviceId = parts.deviceId.trim();
+    return JSON.stringify(body);
+}
+/** Build connect JSON from a parsed QR (strict) or loose scan result. */
+export function sensorQrConnectJsonFromLoose(loose, deviceId) {
+    if (!loose.sn?.trim() || !loose.pin?.trim())
+        return null;
+    return buildSensorQrConnectJson({
+        serial: loose.sn.trim(),
+        pin: loose.pin.trim(),
+        model: loose.model,
+        deviceId,
+    });
+}
+/** Draft QR JSON from a scan row (uses device model / FW hint, keeps existing PIN if provided). */
+export function draftSensorQrConnectJsonFromScanDevice(device, pin = '111111') {
+    const serial = device.serialNumber?.trim();
+    if (!serial)
+        return null;
+    const fw = device.telemetry?.firmware ?? null;
+    const model = normalizeSensorStickerModel(device.model ?? undefined) ??
+        sensorModelFromFirmware(fw);
+    return buildSensorQrConnectJson({
+        serial,
+        pin,
+        model,
+        deviceId: device.deviceId,
+    });
+}
+/** Merge scan `deviceId` / MAC from a selected row into a parsed QR for connect. */
+export function mergeScanTargetIntoSensorQr(qr, device) {
+    if (!device)
+        return qr;
+    const mac = device.bluetoothMacAddress?.includes(':') ? device.bluetoothMacAddress : qr.bluetoothMac;
+    return {
+        ...qr,
+        deviceId: device.deviceId || qr.deviceId,
+        bluetoothMac: mac ?? qr.bluetoothMac,
+    };
+}
+/** Parse QR text and attach scan target (deviceId, MAC) when a row is selected. */
+export function parseSensorQrForConnect(qrText, selectedDevice) {
+    const qr = parseSensorQrJson(qrText);
+    return mergeScanTargetIntoSensorQr(qr, selectedDevice);
+}
+export function formatSensorReadingLine(reading) {
+    return `${reading.typeHex}: ${reading.text}`;
+}

package/dist/decoder.d.ts

@@ -2,6 +2,7 @@ import type { SensorBeaconReading } from './types.js';
 export declare const TEMPVO_SENSOR_MANUFACTURER_ID = 620;
 /** FW6 `0x03` advertisement frame length (bytes after company id). */
 export declare const ADV_FRAME_03_LEN = 22;
+export declare function measurementTypeLabel(mtype: number): string;
 export declare function decodeMeasurementSlot(mtype: number, raw24: number): string;
 export declare function serialKeyFromAdv03Frame(frame: Uint8Array): string | null;
 export declare function macKeyFromAddress(macWithColons: string): string;

package/dist/decoder.js

@@ -44,6 +44,12 @@ function unitForType(mtype) {
             return '';
     }
 }
+export function measurementTypeLabel(mtype) {
+    const spec = MEASURE_SPECS.get(mtype);
+    if (spec)
+        return spec.name.toLowerCase();
+    return `type_${mtype.toString(16).padStart(2, '0')}`;
+}
 export function decodeMeasurementSlot(mtype, raw24) {
     const spec = MEASURE_SPECS.get(mtype);
     if (!spec) {
@@ -200,7 +206,7 @@ function parseScan04(frame) {
         summaryParts.push(text);
         measurements.push({
             typeId: mtype,
-            typeHex: `0x${mtype.toString(16).padStart(2, '0').toUpperCase()}`,
+            typeHex: measurementTypeLabel(mtype),
             raw24: raw24 & 0xffffff,
             text,
             ...parsedValuesFromSlot(mtype, raw24),

package/dist/index.d.ts

@@ -1,12 +1,16 @@
-export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, lookupDeviceKeys, macKeyFromAddress, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
+export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, lookupDeviceKeys, macKeyFromAddress, measurementTypeLabel, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
 export { ingestManufacturerPayload } from './ingest.js';
 export { dataViewToUint8Array, manufacturerPayloadsFromScanRecordBytes, normalizeManufacturerBytes } from './normalize.js';
 export { MEASURE_SPECS, type MeasureSpec } from './measure-specs.js';
 export { createSensorBeaconFrameCache, type SensorBeaconFrameCache, type SensorBeaconMeasurement, type SensorBeaconReading, } from './types.js';
 export { TempivoSensorError, type TempivoSensorErrorCode } from './errors.js';
 export { DEFAULT_SENSOR_MODEL, assertSupportedSensorModel, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
+export { isMissingAdvertisementFirmware, sensorModelFromFirmware, } from './model.js';
+export type { SensorStickerModel } from './model.js';
+export { buildSensorQrConnectJson, draftSensorQrConnectJsonFromScanDevice, formatSensorReadingLine, mergeScanTargetIntoSensorQr, normalizeSensorStickerModel, parseSensorQrForConnect, pinFromSensorQrRecord, resolveSensorBleConnectCredentialsFromPin, sensorQrConnectJsonFromLoose, sensorQrSerialMatchesSelected, serialHexFromSensorQrScan, tryParseSensorQrJson, } from './connect-helpers.js';
+export type { ParsedSensorQrLoose, SensorBleConnectCredentials, } from './connect-helpers.js';
 export { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, } from './calibration.js';
-export { BLE_MAX_MEASUREMENT_INTERVAL_MINUTES, BLE_MAX_TRANSMISSION_INTERVAL_SECONDS, BLE_MIN_MEASUREMENT_INTERVAL_MINUTES, BLE_MIN_TRANSMISSION_INTERVAL_SECONDS, DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
+export { BLE_MAX_MEASUREMENT_INTERVAL_MINUTES, BLE_MAX_TRANSMISSION_INTERVAL_SECONDS, BLE_MIN_MEASUREMENT_INTERVAL_MINUTES, BLE_MIN_TRANSMISSION_INTERVAL_SECONDS, DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationFromDevice, parseSensorConfigurationFromDeviceJson, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
 export type { TempivoSchedule, TempivoScheduleAlways, TempivoScheduleWeek, TempivoSensorCalibration, TempivoSensorConfiguration, TempivoSensorQr, TempivoSensorSessionType, TempivoTemperatureAlert, TempivoTemperatureChannel, TempivoTemperatureMaxAlert, TempivoTemperatureMinAlert, TempivoTemperatureRangeAlert, TempivoTriggerTransmissionResult, } from './session-types.js';
 export { addDeviceFoundListener, connect, disconnect, getCalibration, getConfiguration, isNativeSensorBeaconAvailable, isScanning, requestPermissions, setConfigurationJson, startScan, stopScan, triggerTransmission, } from './native-bridge.js';
 export type { TempivoDeviceFoundSubscription, TempivoNativeCalibration, TempivoNativeMeasurement, TempivoNativePermissionResponse, TempivoNativePermissionStatus, TempivoNativeQr, TempivoNativeTelemetry, TempivoSensorBeaconDevice, } from './native-types.js';

package/dist/index.js

@@ -1,10 +1,12 @@
-export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, lookupDeviceKeys, macKeyFromAddress, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
+export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, lookupDeviceKeys, macKeyFromAddress, measurementTypeLabel, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
 export { ingestManufacturerPayload } from './ingest.js';
 export { dataViewToUint8Array, manufacturerPayloadsFromScanRecordBytes, normalizeManufacturerBytes } from './normalize.js';
 export { MEASURE_SPECS } from './measure-specs.js';
 export { createSensorBeaconFrameCache, } from './types.js';
 export { TempivoSensorError } from './errors.js';
 export { DEFAULT_SENSOR_MODEL, assertSupportedSensorModel, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
+export { isMissingAdvertisementFirmware, sensorModelFromFirmware, } from './model.js';
+export { buildSensorQrConnectJson, draftSensorQrConnectJsonFromScanDevice, formatSensorReadingLine, mergeScanTargetIntoSensorQr, normalizeSensorStickerModel, parseSensorQrForConnect, pinFromSensorQrRecord, resolveSensorBleConnectCredentialsFromPin, sensorQrConnectJsonFromLoose, sensorQrSerialMatchesSelected, serialHexFromSensorQrScan, tryParseSensorQrJson, } from './connect-helpers.js';
 export { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, } from './calibration.js';
-export { BLE_MAX_MEASUREMENT_INTERVAL_MINUTES, BLE_MAX_TRANSMISSION_INTERVAL_SECONDS, BLE_MIN_MEASUREMENT_INTERVAL_MINUTES, BLE_MIN_TRANSMISSION_INTERVAL_SECONDS, DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
+export { BLE_MAX_MEASUREMENT_INTERVAL_MINUTES, BLE_MAX_TRANSMISSION_INTERVAL_SECONDS, BLE_MIN_MEASUREMENT_INTERVAL_MINUTES, BLE_MIN_TRANSMISSION_INTERVAL_SECONDS, DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationFromDevice, parseSensorConfigurationFromDeviceJson, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
 export { addDeviceFoundListener, connect, disconnect, getCalibration, getConfiguration, isNativeSensorBeaconAvailable, isScanning, requestPermissions, setConfigurationJson, startScan, stopScan, triggerTransmission, } from './native-bridge.js';

package/dist/model.d.ts

@@ -0,0 +1,5 @@
+export type SensorStickerModel = 'HC5' | 'HC7';
+/** True when advertisement has no usable firmware semver (incl. SDK placeholder `0.0.0`). */
+export declare function isMissingAdvertisementFirmware(firmware: string | null | undefined): boolean;
+/** Product hint from firmware only. Missing FW → HC7. */
+export declare function sensorModelFromFirmware(firmware: string | null | undefined): SensorStickerModel;

package/dist/model.js

@@ -0,0 +1,25 @@
+import { DEFAULT_SENSOR_MODEL } from './qr.js';
+/** True when advertisement has no usable firmware semver (incl. SDK placeholder `0.0.0`). */
+export function isMissingAdvertisementFirmware(firmware) {
+    const t = firmware?.trim() ?? '';
+    return t.length === 0 || t === '0.0.0';
+}
+/** Product hint from firmware only. Missing FW → HC7. */
+export function sensorModelFromFirmware(firmware) {
+    if (isMissingAdvertisementFirmware(firmware))
+        return DEFAULT_SENSOR_MODEL;
+    const t = firmware.trim();
+    if (/^FW\s*5/i.test(t))
+        return 'HC5';
+    const m = /(?:^FW\s*)?(\d+)\.\d+/i.exec(t);
+    if (!m)
+        return DEFAULT_SENSOR_MODEL;
+    const major = Number(m[1]);
+    if (!Number.isFinite(major))
+        return DEFAULT_SENSOR_MODEL;
+    if (major >= 7)
+        return 'HC7';
+    if (major >= 1)
+        return 'HC5';
+    return DEFAULT_SENSOR_MODEL;
+}

package/dist/native-helpers.js

@@ -12,11 +12,14 @@ const SENSOR_CODES = [
 export function qrToConnectJson(qr) {
     if (typeof qr === 'string')
         return qr;
-    return JSON.stringify({
+    const body = {
         sn: qr.serial,
         pin: qr.pin,
         model: qr.model ?? 'HC7',
-    });
+    };
+    if (qr.deviceId)
+        body.deviceId = qr.deviceId;
+    return JSON.stringify(body);
 }
 export function configToJson(config) {
     return typeof config === 'string' ? config : JSON.stringify(config);

package/dist/native-module.js

@@ -1,7 +1,7 @@
 import { requireOptionalNativeModule } from 'expo-modules-core';
 import { TempivoSensorError } from './errors.js';
 import { configToJson, mapNativeError, qrToConnectJson } from './native-helpers.js';
-import { parseSensorConfigurationJson } from './profile.js';
+import { parseSensorConfigurationFromDeviceJson } from './profile.js';
 function getNative() {
     const native = requireOptionalNativeModule('TempivoSensorBeacon');
     if (!native) {
@@ -76,7 +76,7 @@ export async function disconnect() {
 export async function getConfiguration() {
     try {
         const json = await getNative().getConfigurationJson();
-        return parseSensorConfigurationJson(json);
+        return parseSensorConfigurationFromDeviceJson(json);
     }
     catch (error) {
         throw mapNativeError(error);

package/dist/native-types.d.ts

@@ -27,6 +27,8 @@ export type TempivoNativeTelemetry = {
 export type TempivoSensorBeaconDevice = {
     deviceId: string;
     rssi: number;
+    /** HC7 when advertisement firmware is missing; else inferred from FW major. */
+    model?: string;
     bluetoothMacAddress?: string | null;
     serialNumber?: string | null;
     summary?: string | null;

package/dist/profile.d.ts

@@ -6,10 +6,17 @@ export declare const BLE_MIN_MEASUREMENT_INTERVAL_MINUTES = 60;
 export declare const BLE_MAX_MEASUREMENT_INTERVAL_MINUTES = 600;
 export declare const BLE_MIN_TRANSMISSION_INTERVAL_SECONDS = 3600;
 export declare const BLE_MAX_TRANSMISSION_INTERVAL_SECONDS = 604800;
+export type ParseSensorConfigurationOptions = {
+    /** When true, accept intervals outside partner API limits (device readback). Default false. */
+    fromDevice?: boolean;
+};
 /** Validate Cellular API config-profile JSON for BLE setConfiguration. */
-export declare function parseSensorConfiguration(input: unknown): TempivoSensorConfiguration;
+export declare function parseSensorConfiguration(input: unknown, options?: ParseSensorConfigurationOptions): TempivoSensorConfiguration;
+/** Parse configuration read from the device (intervals may be below partner API minimums). */
+export declare function parseSensorConfigurationFromDevice(input: unknown): TempivoSensorConfiguration;
 /** Same as {@link parseSensorConfiguration}: GET `{ profile }` or the profile object. */
 export declare const configurationFromApiProfile: typeof parseSensorConfiguration;
 export declare function parseSensorConfigurationJson(json: string): TempivoSensorConfiguration;
+export declare function parseSensorConfigurationFromDeviceJson(json: string): TempivoSensorConfiguration;
 export declare function compileSensorProfileToBleJson(input: unknown): string;
 export declare function pickPartnerConfigurationJson(json: string): string;

package/dist/profile.js

@@ -195,18 +195,21 @@ export const BLE_MIN_MEASUREMENT_INTERVAL_MINUTES = 60;
 export const BLE_MAX_MEASUREMENT_INTERVAL_MINUTES = 600;
 export const BLE_MIN_TRANSMISSION_INTERVAL_SECONDS = 3600;
 export const BLE_MAX_TRANSMISSION_INTERVAL_SECONDS = 604_800;
-function parseOptionalIntervals(body) {
+function parseOptionalIntervals(body, options = {}) {
+    const validatePartnerLimits = !options.fromDevice;
     const out = {};
     if (body.measurementIntervalMinutes !== undefined) {
         const n = parseFiniteNumber(body.measurementIntervalMinutes);
         if (n === undefined || !Number.isFinite(n) || n <= 0) {
             throw new TempivoSensorError('invalidConfig', 'measurementIntervalMinutes must be a positive number.');
         }
-        if (n < BLE_MIN_MEASUREMENT_INTERVAL_MINUTES) {
-            throw new TempivoSensorError('invalidConfig', `measurementIntervalMinutes must be at least ${BLE_MIN_MEASUREMENT_INTERVAL_MINUTES} (1 hour).`);
-        }
-        if (n > BLE_MAX_MEASUREMENT_INTERVAL_MINUTES) {
-            throw new TempivoSensorError('invalidConfig', `measurementIntervalMinutes must be at most ${BLE_MAX_MEASUREMENT_INTERVAL_MINUTES}.`);
+        if (validatePartnerLimits) {
+            if (n < BLE_MIN_MEASUREMENT_INTERVAL_MINUTES) {
+                throw new TempivoSensorError('invalidConfig', `measurementIntervalMinutes must be at least ${BLE_MIN_MEASUREMENT_INTERVAL_MINUTES} (1 hour).`);
+            }
+            if (n > BLE_MAX_MEASUREMENT_INTERVAL_MINUTES) {
+                throw new TempivoSensorError('invalidConfig', `measurementIntervalMinutes must be at most ${BLE_MAX_MEASUREMENT_INTERVAL_MINUTES}.`);
+            }
         }
         out.measurementIntervalMinutes = n;
     }
@@ -215,15 +218,18 @@ function parseOptionalIntervals(body) {
         if (n === undefined || !Number.isInteger(n) || n <= 0) {
             throw new TempivoSensorError('invalidConfig', 'transmissionIntervalSeconds must be a positive integer.');
         }
-        if (n < BLE_MIN_TRANSMISSION_INTERVAL_SECONDS) {
-            throw new TempivoSensorError('invalidConfig', `transmissionIntervalSeconds must be at least ${BLE_MIN_TRANSMISSION_INTERVAL_SECONDS} (1 hour).`);
-        }
-        if (n > BLE_MAX_TRANSMISSION_INTERVAL_SECONDS) {
-            throw new TempivoSensorError('invalidConfig', `transmissionIntervalSeconds must be at most ${BLE_MAX_TRANSMISSION_INTERVAL_SECONDS}.`);
+        if (validatePartnerLimits) {
+            if (n < BLE_MIN_TRANSMISSION_INTERVAL_SECONDS) {
+                throw new TempivoSensorError('invalidConfig', `transmissionIntervalSeconds must be at least ${BLE_MIN_TRANSMISSION_INTERVAL_SECONDS} (1 hour).`);
+            }
+            if (n > BLE_MAX_TRANSMISSION_INTERVAL_SECONDS) {
+                throw new TempivoSensorError('invalidConfig', `transmissionIntervalSeconds must be at most ${BLE_MAX_TRANSMISSION_INTERVAL_SECONDS}.`);
+            }
         }
         out.transmissionIntervalSeconds = n;
     }
-    if (out.measurementIntervalMinutes != null &&
+    if (validatePartnerLimits &&
+        out.measurementIntervalMinutes != null &&
         out.transmissionIntervalSeconds != null) {
         const maxTx = out.measurementIntervalMinutes * 60 * 60;
         if (out.transmissionIntervalSeconds > maxTx) {
@@ -232,12 +238,7 @@ function parseOptionalIntervals(body) {
     }
     return out;
 }
-/** Validate Cellular API config-profile JSON for BLE setConfiguration. */
-export function parseSensorConfiguration(input) {
-    if (!isRecord(input)) {
-        throw new TempivoSensorError('invalidConfig', 'Configuration must be a JSON object.');
-    }
-    const body = unwrapApiProfile(input);
+function parseSensorConfigurationBody(body, options = {}) {
     rejectWireAlarmRules(body);
     const alertsRaw = body.temperatureAlerts;
     if (alertsRaw !== undefined && !Array.isArray(alertsRaw)) {
@@ -245,13 +246,25 @@ export function parseSensorConfiguration(input) {
     }
     const temperatureAlerts = (alertsRaw ?? []).map((item, i) => parseAlert(item, i));
     assertAlertSlotBudget(temperatureAlerts);
-    const intervals = parseOptionalIntervals(body);
+    const intervals = parseOptionalIntervals(body, options);
     return {
         temperatureAlerts,
         schedule: parseSchedule(body.schedule),
         ...intervals,
     };
 }
+/** Validate Cellular API config-profile JSON for BLE setConfiguration. */
+export function parseSensorConfiguration(input, options = {}) {
+    if (!isRecord(input)) {
+        throw new TempivoSensorError('invalidConfig', 'Configuration must be a JSON object.');
+    }
+    const body = unwrapApiProfile(input);
+    return parseSensorConfigurationBody(body, options);
+}
+/** Parse configuration read from the device (intervals may be below partner API minimums). */
+export function parseSensorConfigurationFromDevice(input) {
+    return parseSensorConfiguration(input, { fromDevice: true });
+}
 /** Same as {@link parseSensorConfiguration}: GET `{ profile }` or the profile object. */
 export const configurationFromApiProfile = parseSensorConfiguration;
 export function parseSensorConfigurationJson(json) {
@@ -264,6 +277,16 @@ export function parseSensorConfigurationJson(json) {
     }
     return parseSensorConfiguration(parsed);
 }
+export function parseSensorConfigurationFromDeviceJson(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        throw new TempivoSensorError('invalidConfig', 'Configuration is not valid JSON.');
+    }
+    return parseSensorConfigurationFromDevice(parsed);
+}
 export function compileSensorProfileToBleJson(input) {
     return JSON.stringify(parseSensorConfiguration(input));
 }

package/dist/react-native.d.ts

@@ -5,8 +5,12 @@ export { MEASURE_SPECS, type MeasureSpec } from './measure-specs.js';
 export { createSensorBeaconFrameCache, type SensorBeaconFrameCache, type SensorBeaconMeasurement, type SensorBeaconReading, } from './types.js';
 export { TempivoSensorError, type TempivoSensorErrorCode } from './errors.js';
 export { DEFAULT_SENSOR_MODEL, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
+export { isMissingAdvertisementFirmware, sensorModelFromFirmware } from './model.js';
+export type { SensorStickerModel } from './model.js';
+export { buildSensorQrConnectJson, draftSensorQrConnectJsonFromScanDevice, formatSensorReadingLine, mergeScanTargetIntoSensorQr, normalizeSensorStickerModel, parseSensorQrForConnect, pinFromSensorQrRecord, resolveSensorBleConnectCredentialsFromPin, sensorQrConnectJsonFromLoose, sensorQrSerialMatchesSelected, serialHexFromSensorQrScan, tryParseSensorQrJson, } from './connect-helpers.js';
+export type { ParsedSensorQrLoose, SensorBleConnectCredentials } from './connect-helpers.js';
 export { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, } from './calibration.js';
-export { BLE_MAX_MEASUREMENT_INTERVAL_MINUTES, BLE_MAX_TRANSMISSION_INTERVAL_SECONDS, BLE_MIN_MEASUREMENT_INTERVAL_MINUTES, BLE_MIN_TRANSMISSION_INTERVAL_SECONDS, DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
+export { BLE_MAX_MEASUREMENT_INTERVAL_MINUTES, BLE_MAX_TRANSMISSION_INTERVAL_SECONDS, BLE_MIN_MEASUREMENT_INTERVAL_MINUTES, BLE_MIN_TRANSMISSION_INTERVAL_SECONDS, DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationFromDevice, parseSensorConfigurationFromDeviceJson, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
 export type { TempivoSchedule, TempivoScheduleAlways, TempivoScheduleWeek, TempivoSensorCalibration, TempivoSensorConfiguration, TempivoSensorQr, TempivoSensorSessionType, TempivoTemperatureAlert, TempivoTemperatureChannel, TempivoTemperatureMaxAlert, TempivoTemperatureMinAlert, TempivoTemperatureRangeAlert, TempivoTriggerTransmissionResult, } from './session-types.js';
 export type { TempivoDeviceFoundSubscription, TempivoNativeCalibration, TempivoNativeMeasurement, TempivoNativePermissionResponse, TempivoNativePermissionStatus, TempivoNativeQr, TempivoNativeTelemetry, TempivoSensorBeaconDevice, } from './native-types.js';
 import * as native from './native-module.js';

package/dist/react-native.js

@@ -5,8 +5,10 @@ export { MEASURE_SPECS } from './measure-specs.js';
 export { createSensorBeaconFrameCache, } from './types.js';
 export { TempivoSensorError } from './errors.js';
 export { DEFAULT_SENSOR_MODEL, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
+export { isMissingAdvertisementFirmware, sensorModelFromFirmware } from './model.js';
+export { buildSensorQrConnectJson, draftSensorQrConnectJsonFromScanDevice, formatSensorReadingLine, mergeScanTargetIntoSensorQr, normalizeSensorStickerModel, parseSensorQrForConnect, pinFromSensorQrRecord, resolveSensorBleConnectCredentialsFromPin, sensorQrConnectJsonFromLoose, sensorQrSerialMatchesSelected, serialHexFromSensorQrScan, tryParseSensorQrJson, } from './connect-helpers.js';
 export { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, } from './calibration.js';
-export { BLE_MAX_MEASUREMENT_INTERVAL_MINUTES, BLE_MAX_TRANSMISSION_INTERVAL_SECONDS, BLE_MIN_MEASUREMENT_INTERVAL_MINUTES, BLE_MIN_TRANSMISSION_INTERVAL_SECONDS, DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
+export { BLE_MAX_MEASUREMENT_INTERVAL_MINUTES, BLE_MAX_TRANSMISSION_INTERVAL_SECONDS, BLE_MIN_MEASUREMENT_INTERVAL_MINUTES, BLE_MIN_TRANSMISSION_INTERVAL_SECONDS, DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationFromDevice, parseSensorConfigurationFromDeviceJson, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
 import * as native from './native-module.js';
 export const isNativeSensorBeaconAvailable = native.isNativeSensorBeaconAvailable;
 export const requestPermissions = native.requestPermissions;