@tempivo/sensor-beacon 0.1.1 → 0.3.0

package/dist/decoder.js

@@ -151,9 +151,7 @@ function fw5Summary(frame) {
     return `FW 5.x ${maj}.${min} (limited broadcast decode)`;
 }
 function serialMacFromAdv03(frame) {
-    return Array.from(frame.subarray(1, 7))
-        .map((x) => (x & 0xff).toString(16).padStart(2, '0').toUpperCase())
-        .join(':');
+    return serialKeyFromAdv03Frame(frame) ?? '';
 }
 function parseFw6Adv03(frame) {
     if (frame.length < ADV_FRAME_03_LEN)
@@ -183,9 +181,7 @@ function parseFw6Adv03(frame) {
         measurementCounter: ts >>> 0,
         readingTimestampUnix: ts,
         readingTimestampIso,
-        periodBaseSeconds: pbase,
-        periodFactor: pfact,
-        periodLabel: `${pbase}s × ${pfact}`,
+        measurementIntervalSeconds: pbase * pfact,
     };
 }
 function parseScan04(frame) {
@@ -230,9 +226,7 @@ export function buildSensorBeaconReading(adv03, adv04, rawHex = '') {
         measurementCounter: null,
         readingTimestampUnix: null,
         readingTimestampIso: null,
-        periodBaseSeconds: null,
-        periodFactor: null,
-        periodLabel: '',
+        measurementIntervalSeconds: null,
     };
     if (adv03?.length) {
         const tag = u8(adv03, 0);
@@ -282,9 +276,7 @@ export function buildSensorBeaconReading(adv03, adv04, rawHex = '') {
         measurementCounter: base.measurementCounter ?? null,
         readingTimestampUnix: base.readingTimestampUnix ?? null,
         readingTimestampIso: base.readingTimestampIso ?? null,
-        periodBaseSeconds: base.periodBaseSeconds ?? null,
-        periodFactor: base.periodFactor ?? null,
-        periodLabel: base.periodLabel || '—',
+        measurementIntervalSeconds: base.measurementIntervalSeconds ?? null,
         measurements,
         summary: sumOut,
         temperatures,

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+/** Partner-facing error codes. Native runtimes map internal exceptions to these. */
+export type TempivoSensorErrorCode = 'invalidPin' | 'invalidQr' | 'invalidConfig' | 'notConnected' | 'unsupportedCommand' | 'runtimeUnavailable' | 'connectFailed' | 'unknown';
+export declare class TempivoSensorError extends Error {
+    readonly code: TempivoSensorErrorCode;
+    constructor(code: TempivoSensorErrorCode, message: string);
+}

package/dist/errors.js

@@ -0,0 +1,8 @@
+export class TempivoSensorError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'TempivoSensorError';
+        this.code = code;
+    }
+}

package/dist/expo-modules-core.web-stub.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Web/Next stub for optional Expo peer. Native BLE uses the real module in Expo/RN builds.
+ */
+export declare function requireNativeModule(_name: string): never;
+export declare function requireOptionalNativeModule<T = unknown>(_name: string): T | null;

package/dist/expo-modules-core.web-stub.js

@@ -0,0 +1,9 @@
+/**
+ * Web/Next stub for optional Expo peer. Native BLE uses the real module in Expo/RN builds.
+ */
+export function requireNativeModule(_name) {
+    throw new Error('expo-modules-core is not available in the web runtime');
+}
+export function requireOptionalNativeModule(_name) {
+    return null;
+}

package/dist/index.d.ts

@@ -1,5 +1,12 @@
-export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, legacyHintFromFirmware, lookupDeviceKeys, macKeyFromAddress, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
+export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, lookupDeviceKeys, macKeyFromAddress, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
 export { ingestManufacturerPayload } from './ingest.js';
 export { dataViewToUint8Array, 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, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
+export { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, } from './calibration.js';
+export { DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, 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,5 +1,10 @@
-export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, legacyHintFromFirmware, lookupDeviceKeys, macKeyFromAddress, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
+export { ADV_FRAME_03_LEN, TEMPVO_SENSOR_MANUFACTURER_ID, buildSensorBeaconReading, decodeMeasurementSlot, decodeSensorBeaconPayload, lookupDeviceKeys, macKeyFromAddress, serialKeyFromAdv03Frame, splitSensorBeaconFrames, } from './decoder.js';
 export { ingestManufacturerPayload } from './ingest.js';
 export { dataViewToUint8Array, 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, bluetoothMacFromSerial, normalizeSensorSerial, encodeSensorPinPayload, parseSensorQrJson, sessionTypeFromModel, } from './qr.js';
+export { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, } from './calibration.js';
+export { DEFAULT_ALERT_HYSTERESIS_C, compileSensorProfileToBleJson, configurationFromApiProfile, parseSensorConfiguration, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
+export { addDeviceFoundListener, connect, disconnect, getCalibration, getConfiguration, isNativeSensorBeaconAvailable, isScanning, requestPermissions, setConfigurationJson, startScan, stopScan, triggerTransmission, } from './native-bridge.js';

package/dist/native-bridge.d.ts

@@ -0,0 +1,14 @@
+import type { TempivoDeviceFoundSubscription, TempivoNativeCalibration, TempivoNativePermissionResponse, TempivoNativeQr, TempivoSensorBeaconDevice } from './native-types.js';
+import type { TempivoSensorConfiguration, TempivoSensorQr, TempivoTriggerTransmissionResult } from './session-types.js';
+export declare function isNativeSensorBeaconAvailable(): Promise<boolean>;
+export declare function requestPermissions(): Promise<TempivoNativePermissionResponse>;
+export declare function startScan(): Promise<void>;
+export declare function stopScan(): Promise<void>;
+export declare function isScanning(): Promise<boolean>;
+export declare function addDeviceFoundListener(listener: (device: TempivoSensorBeaconDevice) => void): Promise<TempivoDeviceFoundSubscription>;
+export declare function connect(qr: string | TempivoSensorQr): Promise<TempivoNativeQr>;
+export declare function disconnect(): Promise<void>;
+export declare function getConfiguration(): Promise<TempivoSensorConfiguration>;
+export declare function setConfigurationJson(config: string | TempivoSensorConfiguration): Promise<void>;
+export declare function triggerTransmission(): Promise<TempivoTriggerTransmissionResult>;
+export declare function getCalibration(): Promise<TempivoNativeCalibration>;

package/dist/native-bridge.js

@@ -0,0 +1,51 @@
+import { TempivoSensorError } from './errors.js';
+async function loadNative() {
+    try {
+        return await import('./native-module.js');
+    }
+    catch {
+        throw new TempivoSensorError('runtimeUnavailable', 'Native BLE needs an Expo development build or React Native with Expo modules. Expo Go is not supported.');
+    }
+}
+export async function isNativeSensorBeaconAvailable() {
+    try {
+        const native = await import('./native-module.js');
+        return native.isNativeSensorBeaconAvailable();
+    }
+    catch {
+        return false;
+    }
+}
+export async function requestPermissions() {
+    return (await loadNative()).requestPermissions();
+}
+export async function startScan() {
+    return (await loadNative()).startScan();
+}
+export async function stopScan() {
+    (await loadNative()).stopScan();
+}
+export async function isScanning() {
+    return (await loadNative()).isScanning();
+}
+export async function addDeviceFoundListener(listener) {
+    return (await loadNative()).addDeviceFoundListener(listener);
+}
+export async function connect(qr) {
+    return (await loadNative()).connect(qr);
+}
+export async function disconnect() {
+    return (await loadNative()).disconnect();
+}
+export async function getConfiguration() {
+    return (await loadNative()).getConfiguration();
+}
+export async function setConfigurationJson(config) {
+    return (await loadNative()).setConfigurationJson(config);
+}
+export async function triggerTransmission() {
+    return (await loadNative()).triggerTransmission();
+}
+export async function getCalibration() {
+    return (await loadNative()).getCalibration();
+}

package/dist/native-helpers.d.ts

@@ -0,0 +1,5 @@
+import { TempivoSensorError } from './errors.js';
+import type { TempivoSensorConfiguration, TempivoSensorQr } from './session-types.js';
+export declare function qrToConnectJson(qr: string | TempivoSensorQr): string;
+export declare function configToJson(config: string | TempivoSensorConfiguration): string;
+export declare function mapNativeError(error: unknown): TempivoSensorError;

package/dist/native-helpers.js

@@ -0,0 +1,33 @@
+import { TempivoSensorError } from './errors.js';
+const SENSOR_CODES = [
+    'invalidPin',
+    'invalidQr',
+    'invalidConfig',
+    'notConnected',
+    'unsupportedCommand',
+    'runtimeUnavailable',
+    'connectFailed',
+    'unknown',
+];
+export function qrToConnectJson(qr) {
+    if (typeof qr === 'string')
+        return qr;
+    return JSON.stringify({
+        sn: qr.serial,
+        pin: qr.pin,
+        model: qr.model ?? 'HC7',
+    });
+}
+export function configToJson(config) {
+    return typeof config === 'string' ? config : JSON.stringify(config);
+}
+function isSensorCode(value) {
+    return !!value && SENSOR_CODES.includes(value);
+}
+export function mapNativeError(error) {
+    if (error instanceof TempivoSensorError)
+        return error;
+    const raw = error;
+    const code = isSensorCode(raw?.code) ? raw.code : 'unknown';
+    return new TempivoSensorError(code, raw?.message || 'Sensor request failed.');
+}

package/dist/native-module.d.ts

@@ -0,0 +1,14 @@
+import type { TempivoDeviceFoundSubscription, TempivoNativeCalibration, TempivoNativePermissionResponse, TempivoNativeQr, TempivoSensorBeaconDevice } from './native-types.js';
+import type { TempivoSensorConfiguration, TempivoSensorQr, TempivoTriggerTransmissionResult } from './session-types.js';
+export declare function isNativeSensorBeaconAvailable(): boolean;
+export declare function requestPermissions(): Promise<TempivoNativePermissionResponse>;
+export declare function startScan(): Promise<void>;
+export declare function stopScan(): void;
+export declare function isScanning(): boolean;
+export declare function addDeviceFoundListener(listener: (device: TempivoSensorBeaconDevice) => void): TempivoDeviceFoundSubscription;
+export declare function connect(qr: string | TempivoSensorQr): Promise<TempivoNativeQr>;
+export declare function disconnect(): Promise<void>;
+export declare function getConfiguration(): Promise<TempivoSensorConfiguration>;
+export declare function setConfigurationJson(config: string | TempivoSensorConfiguration): Promise<void>;
+export declare function triggerTransmission(): Promise<TempivoTriggerTransmissionResult>;
+export declare function getCalibration(): Promise<TempivoNativeCalibration>;

package/dist/native-module.js

@@ -0,0 +1,104 @@
+import { requireOptionalNativeModule } from 'expo-modules-core';
+import { TempivoSensorError } from './errors.js';
+import { configToJson, mapNativeError, qrToConnectJson } from './native-helpers.js';
+import { parseSensorConfigurationJson } from './profile.js';
+function getNative() {
+    const native = requireOptionalNativeModule('TempivoSensorBeacon');
+    if (!native) {
+        throw new TempivoSensorError('runtimeUnavailable', 'Native BLE needs an Expo development build or React Native with Expo modules. Expo Go is not supported.');
+    }
+    return native;
+}
+export function isNativeSensorBeaconAvailable() {
+    return requireOptionalNativeModule('TempivoSensorBeacon') != null;
+}
+export async function requestPermissions() {
+    try {
+        const result = await getNative().requestPermissions();
+        if (result && typeof result.granted === 'boolean')
+            return result;
+        return {
+            granted: true,
+            status: 'granted',
+            canAskAgain: true,
+            expires: 'never',
+        };
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+async function ensureBlePermission() {
+    const perms = await requestPermissions();
+    if (perms.granted || perms.status === 'undetermined')
+        return;
+    throw new TempivoSensorError('runtimeUnavailable', 'Bluetooth permission is required.');
+}
+export async function startScan() {
+    await ensureBlePermission();
+    try {
+        await getNative().startScan();
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+export function stopScan() {
+    getNative().stopScan();
+}
+export function isScanning() {
+    return getNative().isScanning();
+}
+export function addDeviceFoundListener(listener) {
+    return getNative().addListener('onDeviceFound', listener);
+}
+export async function connect(qr) {
+    await ensureBlePermission();
+    try {
+        return await getNative().connect(qrToConnectJson(qr));
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+export async function disconnect() {
+    try {
+        await getNative().disconnect();
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+export async function getConfiguration() {
+    try {
+        const json = await getNative().getConfigurationJson();
+        return parseSensorConfigurationJson(json);
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+export async function setConfigurationJson(config) {
+    try {
+        await getNative().setConfigurationJson(configToJson(config));
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+export async function triggerTransmission() {
+    try {
+        return await getNative().triggerTransmission();
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+export async function getCalibration() {
+    try {
+        return await getNative().getCalibration();
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}

package/dist/native-types.d.ts

@@ -0,0 +1,41 @@
+import type { TempivoSensorCalibration, TempivoSensorQr, TempivoSensorSessionType } from './session-types.js';
+export type TempivoNativePermissionStatus = 'granted' | 'denied' | 'undetermined';
+export type TempivoNativePermissionResponse = {
+    granted: boolean;
+    status: TempivoNativePermissionStatus;
+    canAskAgain?: boolean;
+    expires?: string;
+};
+export type TempivoNativeMeasurement = {
+    typeHex: string;
+    raw24: number;
+    text: string;
+};
+export type TempivoNativeTelemetry = {
+    firmware?: string | null;
+    batteryOk?: boolean | null;
+    encryptionEnabled?: boolean | null;
+    cellularStatus?: string | null;
+    measurementCounter?: number | null;
+    readingTimestampUnix?: number | null;
+    readingTimestampIso?: string | null;
+    measurementIntervalSeconds?: number | null;
+    readingsCount?: number;
+    summary?: string | null;
+    readings?: TempivoNativeMeasurement[];
+};
+export type TempivoSensorBeaconDevice = {
+    deviceId: string;
+    rssi: number;
+    bluetoothMacAddress?: string | null;
+    serialNumber?: string | null;
+    summary?: string | null;
+    telemetry?: TempivoNativeTelemetry | null;
+};
+export type TempivoNativeQr = TempivoSensorQr & {
+    sessionType: TempivoSensorSessionType;
+};
+export type TempivoNativeCalibration = TempivoSensorCalibration;
+export type TempivoDeviceFoundSubscription = {
+    remove: () => void;
+};

package/dist/native-types.js

@@ -0,0 +1 @@
+export {};

package/dist/profile.d.ts

@@ -0,0 +1,10 @@
+import type { TempivoSensorConfiguration } from './session-types.js';
+/** Same default as Cellular API config profiles. */
+export declare const DEFAULT_ALERT_HYSTERESIS_C = 1;
+/** Validate Cellular API config-profile JSON for BLE setConfiguration. */
+export declare function parseSensorConfiguration(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 compileSensorProfileToBleJson(input: unknown): string;
+export declare function pickPartnerConfigurationJson(json: string): string;

package/dist/profile.js

@@ -0,0 +1,226 @@
+import { TempivoSensorError } from './errors.js';
+const TIME_RE = /^([01]\d|2[0-3]):([0-5]\d)$/;
+/** Same default as Cellular API config profiles. */
+export const DEFAULT_ALERT_HYSTERESIS_C = 1;
+function isRecord(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+function parseFiniteNumber(v) {
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    if (typeof v === 'string' && v.trim() !== '') {
+        const n = Number(v);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return undefined;
+}
+function parseChannel(v) {
+    return v === 'ambient' || v === 'probe' ? v : null;
+}
+function parseOptionalBool(v, fallback, field) {
+    if (v === undefined)
+        return fallback;
+    if (typeof v === 'boolean')
+        return v;
+    throw new TempivoSensorError('invalidConfig', `${field} must be a boolean.`);
+}
+function findPairStart(used) {
+    for (let i = 0; i < 11; i++) {
+        if (!used[i] && !used[i + 1])
+            return i;
+    }
+    return null;
+}
+function findFreeSlot(used) {
+    for (let i = 0; i < 12; i++) {
+        if (!used[i])
+            return i;
+    }
+    return null;
+}
+/** Same 12-slot layout as Cellular API, including one extra slot per range with transmitOnReturn. */
+function assertAlertSlotBudget(alerts) {
+    const used = Array(12).fill(false);
+    const returnLowSlots = [];
+    for (const alert of alerts) {
+        if (alert.type === 'range') {
+            const pair = findPairStart(used);
+            if (pair === null) {
+                throw new TempivoSensorError('invalidConfig', 'Not enough free alarm rule slots for another range (need two consecutive slots).');
+            }
+            used[pair] = true;
+            used[pair + 1] = true;
+            if (alert.transmitOnReturn)
+                returnLowSlots.push(pair);
+        }
+        else {
+            const slot = findFreeSlot(used);
+            if (slot === null) {
+                throw new TempivoSensorError('invalidConfig', 'Not enough free alarm rule slots.');
+            }
+            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;
+    }
+}
+function parseSchedule(raw) {
+    if (raw == null)
+        return { always: true };
+    if (!isRecord(raw)) {
+        throw new TempivoSensorError('invalidConfig', 'schedule must be an object.');
+    }
+    if (raw.always === true)
+        return { always: true };
+    const weekdays = raw.weekdays;
+    if (!Array.isArray(weekdays) || weekdays.length === 0) {
+        throw new TempivoSensorError('invalidConfig', 'schedule.weekdays is required.');
+    }
+    const days = [];
+    for (const d of weekdays) {
+        const n = parseFiniteNumber(d);
+        if (n === undefined || !Number.isInteger(n) || n < 0 || n > 6) {
+            throw new TempivoSensorError('invalidConfig', 'schedule.weekdays must be 0 to 6.');
+        }
+        days.push(n);
+    }
+    const from = typeof raw.from === 'string' ? raw.from.trim() : '';
+    const to = typeof raw.to === 'string' ? raw.to.trim() : '';
+    if (!TIME_RE.test(from) || !TIME_RE.test(to)) {
+        throw new TempivoSensorError('invalidConfig', 'schedule.from and schedule.to must be HH:MM.');
+    }
+    const utc = parseFiniteNumber(raw.utcOffsetMinutes);
+    if (utc === undefined || !Number.isInteger(utc)) {
+        throw new TempivoSensorError('invalidConfig', 'schedule.utcOffsetMinutes is required.');
+    }
+    return { weekdays: days, from, to, utcOffsetMinutes: utc };
+}
+function parseAlert(item, index) {
+    if (!isRecord(item)) {
+        throw new TempivoSensorError('invalidConfig', `temperatureAlerts[${index}] must be an object.`);
+    }
+    const channel = parseChannel(item.channel);
+    if (!channel) {
+        throw new TempivoSensorError('invalidConfig', `temperatureAlerts[${index}].channel must be ambient or probe.`);
+    }
+    if (item.hysteresisC !== undefined) {
+        const hystRaw = parseFiniteNumber(item.hysteresisC);
+        if (hystRaw === undefined || hystRaw < 0) {
+            throw new TempivoSensorError('invalidConfig', `temperatureAlerts[${index}].hysteresisC must be a number 0 or greater.`);
+        }
+    }
+    const hysteresisC = parseFiniteNumber(item.hysteresisC) ?? DEFAULT_ALERT_HYSTERESIS_C;
+    const transmitOnBreach = parseOptionalBool(item.transmitOnBreach, true, `temperatureAlerts[${index}].transmitOnBreach`);
+    if (item.type === 'range') {
+        const lowC = parseFiniteNumber(item.lowC);
+        const highC = parseFiniteNumber(item.highC);
+        if (lowC === undefined || highC === undefined) {
+            throw new TempivoSensorError('invalidConfig', `temperatureAlerts[${index}] needs lowC and highC.`);
+        }
+        if (highC <= lowC) {
+            throw new TempivoSensorError('invalidConfig', `temperatureAlerts[${index}]: highC must be greater than lowC.`);
+        }
+        const transmitOnReturn = parseOptionalBool(item.transmitOnReturn, true, `temperatureAlerts[${index}].transmitOnReturn`);
+        return {
+            type: 'range',
+            channel,
+            lowC,
+            highC,
+            hysteresisC,
+            transmitOnBreach,
+            transmitOnReturn,
+        };
+    }
+    if (item.type === 'min') {
+        const minC = parseFiniteNumber(item.minC);
+        if (minC === undefined) {
+            throw new TempivoSensorError('invalidConfig', `temperatureAlerts[${index}] needs minC.`);
+        }
+        return {
+            type: 'min',
+            channel,
+            minC,
+            hysteresisC,
+            transmitOnBreach,
+        };
+    }
+    if (item.type === 'max') {
+        const maxC = parseFiniteNumber(item.maxC);
+        if (maxC === undefined) {
+            throw new TempivoSensorError('invalidConfig', `temperatureAlerts[${index}] needs maxC.`);
+        }
+        return {
+            type: 'max',
+            channel,
+            maxC,
+            hysteresisC,
+            transmitOnBreach,
+        };
+    }
+    throw new TempivoSensorError('invalidConfig', `temperatureAlerts[${index}].type must be range, min, or max.`);
+}
+function looksLikeSimpleProfile(rec) {
+    return (rec.temperatureAlerts !== undefined ||
+        rec.schedule !== undefined ||
+        typeof rec.slug === 'string');
+}
+/**
+ * GET /devices/config-profiles/{slug} returns `{ profile }`. Also accepts the profile object.
+ */
+function unwrapApiProfile(input) {
+    if (Array.isArray(input.profiles)) {
+        throw new TempivoSensorError('invalidConfig', 'Pass one profile from GET /devices/config-profiles/{slug}, not the list.');
+    }
+    const nested = input.profile;
+    if (isRecord(nested) && looksLikeSimpleProfile(nested)) {
+        return nested;
+    }
+    return input;
+}
+function rejectWireAlarmRules(rec) {
+    if (rec.temperatureAlerts === undefined && rec.alarmRules !== undefined) {
+        throw new TempivoSensorError('invalidConfig', 'Use a config profile with temperatureAlerts (GET /devices/config-profiles/{slug}), not alarmRules.');
+    }
+}
+/** 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);
+    rejectWireAlarmRules(body);
+    const alertsRaw = body.temperatureAlerts;
+    if (alertsRaw !== undefined && !Array.isArray(alertsRaw)) {
+        throw new TempivoSensorError('invalidConfig', 'temperatureAlerts must be an array.');
+    }
+    const temperatureAlerts = (alertsRaw ?? []).map((item, i) => parseAlert(item, i));
+    assertAlertSlotBudget(temperatureAlerts);
+    return {
+        temperatureAlerts,
+        schedule: parseSchedule(body.schedule),
+    };
+}
+/** Same as {@link parseSensorConfiguration}: GET `{ profile }` or the profile object. */
+export const configurationFromApiProfile = parseSensorConfiguration;
+export function parseSensorConfigurationJson(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        throw new TempivoSensorError('invalidConfig', 'Configuration is not valid JSON.');
+    }
+    return parseSensorConfiguration(parsed);
+}
+export function compileSensorProfileToBleJson(input) {
+    return JSON.stringify(parseSensorConfiguration(input));
+}
+export function pickPartnerConfigurationJson(json) {
+    return JSON.stringify(parseSensorConfigurationJson(json));
+}

package/dist/qr.d.ts

@@ -0,0 +1,16 @@
+import type { TempivoSensorQr, TempivoSensorSessionType } from './session-types.js';
+export declare function normalizeSensorSerial(value: string): string;
+/** `282C024F0012` → `28:2C:02:4F:00:12`. */
+export declare function bluetoothMacFromSerial(serial: string): string;
+/** BLE default when QR omits `model`. HC5 / FW 6.x still select legacy. */
+export declare const DEFAULT_SENSOR_MODEL = "HC7";
+export declare function sessionTypeFromModel(model: string | undefined | null): TempivoSensorSessionType;
+/**
+ * 3-byte big-endian numeric PIN for GATT command payloads that check a reset code
+ * (`setConfiguration`, trigger, and many other privileged writes).
+ */
+export declare function encodeSensorPinPayload(pin: string): Uint8Array;
+/**
+ * Parse sensor label QR JSON: `{"sn":"…","pin":"…","model":"HC7"}`.
+ */
+export declare function parseSensorQrJson(text: string): TempivoSensorQr;