@tempivo/sensor-beacon 1.1.6 → 1.1.8

package/dist/config-errors.js

@@ -0,0 +1,244 @@
+/**
+ * Decode ProtoConfig.configurationErrors (uint32 codes) from BLE get.
+ * Wire: (side << 14) | (parameter << 8) | value
+ */
+const SIDE_BY_INDEX = {
+    0: 'BLE',
+    1: 'SERVER',
+    2: 'INTERNAL',
+};
+const PARAMETER_BY_INDEX = {
+    0: 'RULE0',
+    1: 'RULE1',
+    2: 'RULE2',
+    3: 'RULE3',
+    4: 'RULE4',
+    5: 'RULE5',
+    6: 'RULE6',
+    7: 'RULE7',
+    8: 'RULE8',
+    9: 'RULE9',
+    10: 'RULE10',
+    11: 'RULE11',
+    12: 'CACHE',
+    13: 'MEASUREMENT_PERIOD',
+    14: 'BLE_TURNOFF_TIME',
+    15: 'TRANSFER_LIMIT',
+    16: 'TRANSMISSION_INTERVAL',
+    17: 'DATA_SERVER_CONFIG',
+    18: 'UPDATE_SERVER_CONFIG',
+    19: 'CLOUD_TOKEN',
+    20: 'SUPERVISION_PERIOD',
+    21: 'DEVICE_INFO_ENDPOINT',
+    22: 'TIME_ENDPOINT',
+    23: 'BLUETOOTH_TX_POWER',
+    24: 'TIME_SYNCHRONIZATION_CONFIG',
+    25: 'DNS_TTL_CONFIG',
+    26: 'CELLULAR_CONFIG',
+    27: 'RULE_CALENDAR_0',
+    28: 'RULE_CALENDAR_1',
+    29: 'RULE_CALENDAR_2',
+    30: 'RULE_CALENDAR_3',
+    31: 'RULE_CALENDAR_4',
+    32: 'RULE_CALENDAR_5',
+    33: 'LED',
+    34: 'NETWORK',
+    35: 'ENCRYPTION',
+    59: 'CONFIG_PAYLOAD_OR_REQUEST',
+    60: 'DATA_SENDING_ALGORITHM',
+    61: 'OUTPUT_CONTROL',
+};
+const VALUE_BY_INDEX = {
+    0: 'NO_ERROR',
+    1: 'VALUE_OUT_OF_RANGE',
+    2: 'IMPOSSIBLE_TO_CONNECT_TO_THE_SET_SERVER',
+    3: 'INVALID_IP_ADDRESS',
+    4: 'INVALID_APN',
+    5: 'INVALID_PLMN',
+    6: 'INVALID_BANDS',
+    7: 'INVALID_CLOUD_TOKEN_VALUE',
+    8: 'INVALID_CLOUD_TOKEN_CONFIG',
+    9: 'INVALID_CONDITION',
+    10: 'INVALID_ACTION',
+    11: 'INVALID_SLOTS',
+    12: 'INVALID_PARAMS',
+    13: 'TIMEOUT',
+    14: 'INVALID_COAP_ENDPOINT',
+    15: 'FAILED_TO_DECODE_PROTOBUF_PAYLOAD',
+    16: 'INCORRECT_SENSOR_BEHAVIOR_NO_MEASUREMENTS_AT_PLANNED_TRANSMISSION_OVER_NB_IOT',
+    17: 'INVALID_CLOUD_TOKEN_COAP_OPTION',
+    18: 'INVALID_PAYLOAD_SIGNATURE_COAP_OPTION',
+    19: 'INVALID_DNS_SERVER_IP_ADDRESS',
+    20: 'INVALID_COAP_PORT',
+    21: 'INVALID_UDP_PORT',
+    22: 'INVALID_CHANNEL_CONTROL_REQUEST',
+    23: 'INVALID_RULE_MASK',
+    24: 'INVALID_CALIBRATION_PARAMETERS_REQUEST',
+    25: 'PREVIOUS_CONFIGURATION_IS_IN_PROGRESS',
+};
+const SIDE_LABEL = {
+    BLE: 'BLE apply',
+    SERVER: 'Server connectivity test',
+    INTERNAL: 'Device internal',
+    UNRECOGNIZED: 'Unknown source',
+};
+/** 1-based rule/calendar labels for partners (RULE0 → Alarm rule 1). */
+const PARAMETER_LABEL = {
+    RULE0: 'Alarm rule 1',
+    RULE1: 'Alarm rule 2',
+    RULE2: 'Alarm rule 3',
+    RULE3: 'Alarm rule 4',
+    RULE4: 'Alarm rule 5',
+    RULE5: 'Alarm rule 6',
+    RULE6: 'Alarm rule 7',
+    RULE7: 'Alarm rule 8',
+    RULE8: 'Alarm rule 9',
+    RULE9: 'Alarm rule 10',
+    RULE10: 'Alarm rule 11',
+    RULE11: 'Alarm rule 12',
+    CACHE: 'Cache',
+    MEASUREMENT_PERIOD: 'Measurement period',
+    BLE_TURNOFF_TIME: 'BLE turnoff time',
+    TRANSFER_LIMIT: 'Transfer limit',
+    TRANSMISSION_INTERVAL: 'Transmission interval',
+    DATA_SERVER_CONFIG: 'Data server (SERVER_DATA)',
+    UPDATE_SERVER_CONFIG: 'Update server (SERVER_UPDATE)',
+    CLOUD_TOKEN: 'Cloud token',
+    SUPERVISION_PERIOD: 'Supervision period',
+    DEVICE_INFO_ENDPOINT: 'Device info endpoint',
+    TIME_ENDPOINT: 'Time endpoint',
+    BLUETOOTH_TX_POWER: 'BLE TX power',
+    TIME_SYNCHRONIZATION_CONFIG: 'Time sync',
+    DNS_TTL_CONFIG: 'DNS TTL',
+    CELLULAR_CONFIG: 'Cellular config',
+    RULE_CALENDAR_0: 'Calendar 1',
+    RULE_CALENDAR_1: 'Calendar 2',
+    RULE_CALENDAR_2: 'Calendar 3',
+    RULE_CALENDAR_3: 'Calendar 4',
+    RULE_CALENDAR_4: 'Calendar 5',
+    RULE_CALENDAR_5: 'Calendar 6',
+    LED: 'LED config',
+    NETWORK: 'Network (APN/PLMN/bands)',
+    ENCRYPTION: 'Encryption key',
+    CONFIG_PAYLOAD_OR_REQUEST: 'Config payload',
+    DATA_SENDING_ALGORITHM: 'Data sending',
+    OUTPUT_CONTROL: 'Output control',
+    UNRECOGNIZED: 'Unknown parameter',
+};
+const VALUE_LABEL = {
+    NO_ERROR: 'No error',
+    VALUE_OUT_OF_RANGE: 'Value out of range',
+    IMPOSSIBLE_TO_CONNECT_TO_THE_SET_SERVER: 'Cannot reach configured server',
+    INVALID_IP_ADDRESS: 'Invalid IP address',
+    INVALID_APN: 'Invalid APN',
+    INVALID_PLMN: 'Invalid PLMN',
+    INVALID_BANDS: 'Invalid bands',
+    INVALID_CLOUD_TOKEN_VALUE: 'Invalid cloud token value',
+    INVALID_CLOUD_TOKEN_CONFIG: 'Invalid cloud token config',
+    INVALID_CONDITION: 'Invalid rule condition',
+    INVALID_ACTION: 'Invalid rule action',
+    INVALID_SLOTS: 'Invalid channel slots',
+    INVALID_PARAMS: 'Invalid parameters',
+    TIMEOUT: 'Connection timeout',
+    INVALID_COAP_ENDPOINT: 'Invalid CoAP endpoint',
+    FAILED_TO_DECODE_PROTOBUF_PAYLOAD: 'Invalid config payload',
+    INCORRECT_SENSOR_BEHAVIOR_NO_MEASUREMENTS_AT_PLANNED_TRANSMISSION_OVER_NB_IOT: 'No measurements at planned NB-IoT transmission',
+    INVALID_CLOUD_TOKEN_COAP_OPTION: 'Invalid cloud token CoAP option',
+    INVALID_PAYLOAD_SIGNATURE_COAP_OPTION: 'Invalid payload signature option',
+    INVALID_DNS_SERVER_IP_ADDRESS: 'Invalid DNS server IP',
+    INVALID_COAP_PORT: 'Invalid CoAP port',
+    INVALID_UDP_PORT: 'Invalid UDP port',
+    INVALID_CHANNEL_CONTROL_REQUEST: 'Invalid output control request',
+    INVALID_RULE_MASK: 'Invalid rule mask',
+    INVALID_CALIBRATION_PARAMETERS_REQUEST: 'Invalid calibration request',
+    PREVIOUS_CONFIGURATION_IS_IN_PROGRESS: 'Previous config still applying',
+    UNRECOGNIZED: 'Unknown reason',
+};
+export function decodeConfigurationError(raw) {
+    const code = Math.trunc(raw);
+    const valueIndex = code & 0xff;
+    const parameterIndex = (code >> 8) & 0x3f;
+    const sideIndex = (code >> 14) & 0x3;
+    const side = SIDE_BY_INDEX[sideIndex] ?? 'UNRECOGNIZED';
+    const parameter = PARAMETER_BY_INDEX[parameterIndex] ?? 'UNRECOGNIZED';
+    const value = VALUE_BY_INDEX[valueIndex] ?? 'UNRECOGNIZED';
+    return {
+        raw: code,
+        side,
+        parameter,
+        value,
+        label: `${SIDE_LABEL[side]} · ${PARAMETER_LABEL[parameter]} · ${VALUE_LABEL[value]}`,
+    };
+}
+export function decodeConfigurationErrorCodes(rawCodes) {
+    return rawCodes
+        .filter((c) => typeof c === 'number' && Number.isFinite(c))
+        .map((c) => decodeConfigurationError(c));
+}
+function asUint32List(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const item of value) {
+        if (typeof item === 'number' && Number.isFinite(item)) {
+            out.push(Math.trunc(item));
+            continue;
+        }
+        if (typeof item === 'string' && /^\d+$/.test(item.trim())) {
+            out.push(parseInt(item.trim(), 10));
+        }
+    }
+    return out;
+}
+function asUnixSeconds(value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0)
+        return Math.trunc(value);
+    if (typeof value === 'string' && /^\d+$/.test(value.trim())) {
+        const n = parseInt(value.trim(), 10);
+        return n > 0 ? n : null;
+    }
+    return null;
+}
+function pad2(n) {
+    return n < 10 ? `0${n}` : String(n);
+}
+/**
+ * Format ProtoConfig.configurationErrorTimestamp as `YYYY-MM-DD HH:mm:ss UTC`.
+ * Accepts unix seconds (number/string) or ISO / loader UTC strings.
+ */
+export function formatConfigurationErrorTimestamp(value) {
+    if (value == null || value === '')
+        return null;
+    let seconds = asUnixSeconds(value);
+    if (seconds == null && typeof value === 'string') {
+        const trimmed = value.trim();
+        const utcMatch = /^(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2}:\d{2})\s+UTC$/i.exec(trimmed);
+        if (utcMatch) {
+            const d = new Date(`${utcMatch[1]}T${utcMatch[2]}Z`);
+            if (!Number.isNaN(d.getTime()))
+                seconds = Math.floor(d.getTime() / 1000);
+        }
+        else {
+            const d = new Date(trimmed);
+            if (!Number.isNaN(d.getTime()))
+                seconds = Math.floor(d.getTime() / 1000);
+        }
+    }
+    if (seconds == null || seconds <= 0)
+        return null;
+    const d = new Date(seconds * 1000);
+    if (Number.isNaN(d.getTime()))
+        return null;
+    return (`${d.getUTCFullYear()}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())} ` +
+        `${pad2(d.getUTCHours())}:${pad2(d.getUTCMinutes())}:${pad2(d.getUTCSeconds())} UTC`);
+}
+/** Parse `configurationErrors` + timestamp from a decoded ProtoConfig object. */
+export function configurationErrorsFromProtoConfig(proto) {
+    const errors = decodeConfigurationErrorCodes(asUint32List(proto.configurationErrors ?? proto.configuration_errors));
+    const errorTimestampUnix = asUnixSeconds(proto.configurationErrorTimestamp ?? proto.configuration_error_timestamp);
+    return {
+        errors,
+        errorTimestampUnix,
+        errorTimestampUtc: formatConfigurationErrorTimestamp(errorTimestampUnix),
+    };
+}

package/dist/index.d.ts

@@ -9,8 +9,20 @@ export { isMissingAdvertisementFirmware, sensorModelFromFirmware, } from './mode
 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 { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, formatLaboratoryCalibration, normalizeLaboratoryCalibration, } 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, parseSensorConfigurationFromDevice, parseSensorConfigurationFromDeviceJson, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
+export { PROBE_CHANNEL_INDEX_0, alertsRequireProbe, assertProbeAlertsAllowed, channelTypesFromProtoConfig, deviceSupportsProbeFromBeaconReadings, deviceSupportsProbeFromChannelTypes, isTemperatureReadingType, resolveProbeSupported, } from './channel-capability.js';
+export type { ProbeCapabilitySource } from './channel-capability.js';
+export { configurationErrorsFromProtoConfig, decodeConfigurationError, decodeConfigurationErrorCodes, formatConfigurationErrorTimestamp, } from './config-errors.js';
+export type { TempivoConfigErrorParameter, TempivoConfigErrorSide, TempivoConfigErrorValue, TempivoConfigurationError, TempivoConfigurationErrors, } from './config-errors.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, getProtoConfiguration, isNativeSensorBeaconAvailable, isScanning, requestPermissions, setConfigurationJson, startScan, stopScan, triggerTransmission, } from './native-bridge.js';
+export { addDeviceFoundListener, connect, clearMeasurementQueue, deleteMeasurements, disconnect, getCalibration, getCellularNetworkStatus, getCellularNetworkStatusJson, getConfiguration, getConfigurationErrors, getProtoConfiguration, isNativeSensorBeaconAvailable, isScanning, requestPermissions, setConfigurationJson, setOperator, startScan, stopScan, triggerTransmission, } from './native-bridge.js';
+export { cellularNetworkStatusViewFromJson, formatCellularNetworkStatusLabel, formatCellularNetworkStatusLabelWithOperator, formatCellularNetworkStatusSummary, formatCellularServerDetailLabel, isCellularConnectionFullyOk, isCellularRegistrationOk, isCellularServerCommunicationOk, isSimCardOk, isValidCellularIpAddress, normalizeCellularSignalStrengthDbm, parseCellularNetworkStatusJson, parseCellularNetworkStatusObject, resolveCellularStatusTone, } from './cellular-network-status.js';
+export type { TempivoCellularNetworkStatus, TempivoCellularNetworkStatusView, TempivoCellularStatusLocale, TempivoCellularStatusTone, } from './cellular-network-status.js';
+export { PREFERRED_PLMN_BY_COUNTRY_ISO2, PREFERRED_PLMN_FALLBACK, normalizeCountryIso2, resolveSetOperator, } from './plmn-by-country.js';
+export type { SetOperatorArg } from './plmn-by-country.js';
+export { getOperatorNameFromPlmn, PLMN_OPERATOR_LABELS } from './plmn-labels.js';
+export type { TempivoPlmnOperatorOption } from './plmn-labels.js';
 export type { TempivoDeviceFoundSubscription, TempivoNativeCalibration, TempivoNativeMeasurement, TempivoNativePermissionResponse, TempivoNativePermissionStatus, TempivoNativeQr, TempivoNativeTelemetry, TempivoSensorBeaconDevice, } from './native-types.js';
+export { checkProductionDefaults } from './production-defaults.js';
+export type { ProductionCheckLine, ProductionCheckResult } from './production-defaults.js';

package/dist/index.js

@@ -7,6 +7,12 @@ 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 { calibrationFromExtendedJson, decodeLaboratoryCalibrationTimestamp, formatLaboratoryCalibration, normalizeLaboratoryCalibration, } 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, parseSensorConfigurationFromDevice, parseSensorConfigurationFromDeviceJson, parseSensorConfigurationJson, pickPartnerConfigurationJson, } from './profile.js';
-export { addDeviceFoundListener, connect, disconnect, getCalibration, getConfiguration, getProtoConfiguration, isNativeSensorBeaconAvailable, isScanning, requestPermissions, setConfigurationJson, startScan, stopScan, triggerTransmission, } from './native-bridge.js';
+export { PROBE_CHANNEL_INDEX_0, alertsRequireProbe, assertProbeAlertsAllowed, channelTypesFromProtoConfig, deviceSupportsProbeFromBeaconReadings, deviceSupportsProbeFromChannelTypes, isTemperatureReadingType, resolveProbeSupported, } from './channel-capability.js';
+export { configurationErrorsFromProtoConfig, decodeConfigurationError, decodeConfigurationErrorCodes, formatConfigurationErrorTimestamp, } from './config-errors.js';
+export { addDeviceFoundListener, connect, clearMeasurementQueue, deleteMeasurements, disconnect, getCalibration, getCellularNetworkStatus, getCellularNetworkStatusJson, getConfiguration, getConfigurationErrors, getProtoConfiguration, isNativeSensorBeaconAvailable, isScanning, requestPermissions, setConfigurationJson, setOperator, startScan, stopScan, triggerTransmission, } from './native-bridge.js';
+export { cellularNetworkStatusViewFromJson, formatCellularNetworkStatusLabel, formatCellularNetworkStatusLabelWithOperator, formatCellularNetworkStatusSummary, formatCellularServerDetailLabel, isCellularConnectionFullyOk, isCellularRegistrationOk, isCellularServerCommunicationOk, isSimCardOk, isValidCellularIpAddress, normalizeCellularSignalStrengthDbm, parseCellularNetworkStatusJson, parseCellularNetworkStatusObject, resolveCellularStatusTone, } from './cellular-network-status.js';
+export { PREFERRED_PLMN_BY_COUNTRY_ISO2, PREFERRED_PLMN_FALLBACK, normalizeCountryIso2, resolveSetOperator, } from './plmn-by-country.js';
+export { getOperatorNameFromPlmn, PLMN_OPERATOR_LABELS } from './plmn-labels.js';
+export { checkProductionDefaults } from './production-defaults.js';

package/dist/native-bridge.d.ts

@@ -1,3 +1,4 @@
+import { type TempivoCellularNetworkStatusView, type TempivoCellularStatusLocale } from './cellular-network-status.js';
 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>;
@@ -11,5 +12,19 @@ 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 clearMeasurementQueue(): Promise<{
+    ok: boolean;
+}>;
+/** Alias for {@link clearMeasurementQueue}. */
+export declare function deleteMeasurements(): Promise<{
+    ok: boolean;
+}>;
+export declare function getCellularNetworkStatusJson(): Promise<string>;
+export declare function getCellularNetworkStatus(opts?: {
+    locale?: TempivoCellularStatusLocale;
+    afterServerTrigger?: boolean;
+}): Promise<TempivoCellularNetworkStatusView>;
+export declare function setOperator(countryOrAuto: string): Promise<void>;
 export declare function getCalibration(): Promise<TempivoNativeCalibration>;
 export declare function getProtoConfiguration(): Promise<Record<string, unknown>>;
+export declare function getConfigurationErrors(): Promise<import("./config-errors.js").TempivoConfigurationErrors>;

package/dist/native-bridge.js

@@ -1,3 +1,4 @@
+import { cellularNetworkStatusViewFromJson, } from './cellular-network-status.js';
 import { TempivoSensorError } from './errors.js';
 async function loadNative() {
     try {
@@ -46,9 +47,29 @@ export async function setConfigurationJson(config) {
 export async function triggerTransmission() {
     return (await loadNative()).triggerTransmission();
 }
+export async function clearMeasurementQueue() {
+    return (await loadNative()).clearMeasurementQueue();
+}
+/** Alias for {@link clearMeasurementQueue}. */
+export async function deleteMeasurements() {
+    return (await loadNative()).deleteMeasurements();
+}
+export async function getCellularNetworkStatusJson() {
+    return (await loadNative()).getCellularNetworkStatusJson();
+}
+export async function getCellularNetworkStatus(opts) {
+    const json = await getCellularNetworkStatusJson();
+    return cellularNetworkStatusViewFromJson(json, opts);
+}
+export async function setOperator(countryOrAuto) {
+    return (await loadNative()).setOperator(countryOrAuto);
+}
 export async function getCalibration() {
     return (await loadNative()).getCalibration();
 }
 export async function getProtoConfiguration() {
     return (await loadNative()).getProtoConfiguration();
 }
+export async function getConfigurationErrors() {
+    return (await loadNative()).getConfigurationErrors();
+}

package/dist/native-module.d.ts

@@ -1,6 +1,8 @@
+import { type TempivoConfigurationErrors } from './config-errors.js';
 import type { TempivoDeviceFoundSubscription, TempivoNativeCalibration, TempivoNativePermissionResponse, TempivoNativeQr, TempivoSensorBeaconDevice } from './native-types.js';
 import { type ProtoConfigObject } from './proto/decode-proto-config.js';
 import type { TempivoSensorConfiguration, TempivoSensorQr, TempivoTriggerTransmissionResult } from './session-types.js';
+export type { TempivoConfigurationErrors };
 export declare function isNativeSensorBeaconAvailable(): boolean;
 export declare function requestPermissions(): Promise<TempivoNativePermissionResponse>;
 export declare function startScan(): Promise<void>;
@@ -22,6 +24,30 @@ export declare function getConfiguration(): Promise<TempivoSensorConfiguration>;
  */
 export declare function setConfigurationJson(config: string | TempivoSensorConfiguration): Promise<void>;
 export declare function triggerTransmission(): Promise<TempivoTriggerTransmissionResult>;
+/**
+ * Clear on-device measurement / uplink queue (memory reset).
+ * Manual recovery only: not used by setConfigurationJson.
+ */
+export declare function clearMeasurementQueue(): Promise<{
+    ok: boolean;
+}>;
+/** Alias for {@link clearMeasurementQueue} (delete stored measurements on the sensor). */
+export declare function deleteMeasurements(): Promise<{
+    ok: boolean;
+}>;
+/** GATT cellular network status JSON (registration, IP, PLMN). Same family as Tempivo app. */
+export declare function getCellularNetworkStatusJson(): Promise<string>;
+/**
+ * Set PLMN AUTO or preferred operator for a country ISO (`SE`, `NO`, …).
+ * Native merges PLMN into getConfiguration (sanitized). Avoids raw ProtoConfig write.
+ */
+export declare function setOperator(countryOrAuto: string): Promise<void>;
 /** Decoded device ProtoConfig (server, APN, intervals). Requires an open BLE session. */
 export declare function getProtoConfiguration(): Promise<ProtoConfigObject>;
+/**
+ * Read `configurationErrors` from the device ProtoConfig over BLE.
+ * Same GATT get as {@link getProtoConfiguration}; decoded for partner apps.
+ * Empty `errors` means the device reports none (or firmware cleared them).
+ */
+export declare function getConfigurationErrors(): Promise<TempivoConfigurationErrors>;
 export declare function getCalibration(): Promise<TempivoNativeCalibration>;

package/dist/native-module.js

@@ -1,4 +1,6 @@
 import { requireOptionalNativeModule } from 'expo-modules-core';
+import { normalizeLaboratoryCalibration, } from './calibration.js';
+import { configurationErrorsFromProtoConfig, } from './config-errors.js';
 import { TempivoSensorError } from './errors.js';
 import { configToJson, mapNativeError, qrToConnectJson } from './native-helpers.js';
 import { decodeProtoConfigBase64 } from './proto/decode-proto-config.js';
@@ -37,9 +39,25 @@ async function ensureBlePermission() {
         return;
     throw new TempivoSensorError('runtimeUnavailable', 'Bluetooth permission is required.');
 }
+/**
+ * Drop a leftover native GATT session once per JS runtime (Metro reload / app relaunch
+ * often keeps the Android/iOS module alive while wiping JS). Without this, the sensor
+ * stops advertising until someone calls {@link disconnect}.
+ */
+let releaseStaleGattOnceStarted = false;
+function releaseStaleGattSessionOnce() {
+    if (releaseStaleGattOnceStarted)
+        return;
+    if (!isNativeSensorBeaconAvailable())
+        return;
+    releaseStaleGattOnceStarted = true;
+    void disconnect().catch(() => undefined);
+}
 export async function startScan() {
     await ensureBlePermission();
     try {
+        // Own GATT blocks advertising for that sensor; release before scan.
+        await disconnect().catch(() => undefined);
         await getNative().startScan();
     }
     catch (error) {
@@ -62,6 +80,7 @@ export function addDeviceFoundListener(listener) {
 export async function connect(qr) {
     await ensureBlePermission();
     try {
+        releaseStaleGattSessionOnce();
         return await getNative().connect(qrToConnectJson(qr));
     }
     catch (error) {
@@ -142,6 +161,92 @@ export async function triggerTransmission() {
         throw mapNativeError(error);
     }
 }
+/**
+ * Clear on-device measurement / uplink queue (memory reset).
+ * Manual recovery only: not used by setConfigurationJson.
+ */
+export async function clearMeasurementQueue() {
+    try {
+        const native = getNative();
+        if (typeof native.clearMeasurementQueue !== 'function') {
+            throw new TempivoSensorError('runtimeUnavailable', 'Native clearMeasurementQueue is unavailable in this build.');
+        }
+        return await withTimeout(native.clearMeasurementQueue(), 45_000, 'clearMeasurementQueue');
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+/** Alias for {@link clearMeasurementQueue} (delete stored measurements on the sensor). */
+export async function deleteMeasurements() {
+    return clearMeasurementQueue();
+}
+/** GATT cellular network status JSON (registration, IP, PLMN). Same family as Tempivo app. */
+export async function getCellularNetworkStatusJson() {
+    try {
+        const native = getNative();
+        if (typeof native.getCellularNetworkStatusJson !== 'function') {
+            throw new TempivoSensorError('runtimeUnavailable', 'Native getCellularNetworkStatusJson is unavailable in this build.');
+        }
+        return await native.getCellularNetworkStatusJson();
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+/** Preferred PLMN map (keep in sync with `plmn-by-country.ts`). Inlined for Metro file: links. */
+const PREFERRED_PLMN_BY_COUNTRY_ISO2 = {
+    SE: 24001,
+    NO: 24201,
+    DK: 23820,
+    FI: 24491,
+    GB: 23415,
+    UK: 23415,
+    DE: 26201,
+    FR: 20801,
+    IT: 22201,
+    ES: 21401,
+};
+/**
+ * Set PLMN AUTO or preferred operator for a country ISO (`SE`, `NO`, …).
+ * Native merges PLMN into getConfiguration (sanitized). Avoids raw ProtoConfig write.
+ */
+export async function setOperator(countryOrAuto) {
+    const raw = String(countryOrAuto ?? '').trim();
+    const automatic = !raw || raw.toUpperCase() === 'AUTO';
+    let plmn = null;
+    if (!automatic) {
+        const iso = raw.toUpperCase();
+        if (!/^[A-Z]{2}$/.test(iso)) {
+            throw new TempivoSensorError('unknown', `Invalid country ISO: ${raw}`);
+        }
+        plmn = PREFERRED_PLMN_BY_COUNTRY_ISO2[iso] ?? 24001;
+    }
+    try {
+        const native = getNative();
+        if (typeof native.setOperator !== 'function') {
+            throw new TempivoSensorError('runtimeUnavailable', 'Native setOperator is unavailable in this build.');
+        }
+        await withTimeout(native.setOperator(automatic, plmn), 45_000, 'setOperator');
+    }
+    catch (error) {
+        throw mapNativeError(error);
+    }
+}
+function withTimeout(promise, ms, label) {
+    return new Promise((resolve, reject) => {
+        const id = setTimeout(() => {
+            reject(new TempivoSensorError('unknown', `${label} timed out after ${ms}ms.`));
+        }, ms);
+        promise.then((v) => {
+            clearTimeout(id);
+            resolve(v);
+        }, (e) => {
+            clearTimeout(id);
+            reject(e);
+        });
+    });
+}
 /** Decoded device ProtoConfig (server, APN, intervals). Requires an open BLE session. */
 export async function getProtoConfiguration() {
     try {
@@ -158,11 +263,37 @@ export async function getProtoConfiguration() {
         throw mapNativeError(error);
     }
 }
+/**
+ * Read `configurationErrors` from the device ProtoConfig over BLE.
+ * Same GATT get as {@link getProtoConfiguration}; decoded for partner apps.
+ * Empty `errors` means the device reports none (or firmware cleared them).
+ */
+export async function getConfigurationErrors() {
+    const proto = await getProtoConfiguration();
+    return configurationErrorsFromProtoConfig(proto);
+}
 export async function getCalibration() {
     try {
-        return await getNative().getCalibration();
+        const raw = await getNative().getCalibration();
+        const payload = raw && typeof raw === 'object' ? raw : null;
+        try {
+            return normalizeLaboratoryCalibration(payload);
+        }
+        catch {
+            // Keep BLE session usable even if formatting helpers misbehave.
+            return {
+                laboratoryCalibrationDate: typeof payload?.laboratoryCalibrationDate === 'string'
+                    ? payload.laboratoryCalibrationDate
+                    : null,
+                laboratoryCalibrationTimestamp: typeof payload?.laboratoryCalibrationTimestamp === 'number'
+                    ? payload.laboratoryCalibrationTimestamp
+                    : null,
+            };
+        }
     }
     catch (error) {
         throw mapNativeError(error);
     }
 }
+// Metro / process reuse: release any leftover GATT as soon as this module loads.
+releaseStaleGattSessionOnce();

package/dist/plmn-by-country.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Preferred NB-IoT PLMN per ISO 3166-1 alpha-2 (hardcoded for partner SDK).
+ * Keep in sync with app `src/lib/default-plmn-by-country.ts`.
+ */
+export declare const PREFERRED_PLMN_BY_COUNTRY_ISO2: Record<string, number>;
+export declare const PREFERRED_PLMN_FALLBACK = 24001;
+export declare function normalizeCountryIso2(code: string | null | undefined): string | null;
+/** `AUTO` or ISO2 → PLMN mode for BLE. */
+export type SetOperatorArg = 'AUTO' | string;
+export declare function resolveSetOperator(arg: SetOperatorArg): {
+    mode: 'AUTO' | 'VALUE';
+    plmn?: number;
+    countryIso?: string;
+};

package/dist/plmn-by-country.js

@@ -0,0 +1,35 @@
+/**
+ * Preferred NB-IoT PLMN per ISO 3166-1 alpha-2 (hardcoded for partner SDK).
+ * Keep in sync with app `src/lib/default-plmn-by-country.ts`.
+ */
+export const PREFERRED_PLMN_BY_COUNTRY_ISO2 = {
+    SE: 24001,
+    NO: 24201,
+    DK: 23820,
+    FI: 24491,
+    GB: 23415,
+    UK: 23415,
+    DE: 26201,
+    FR: 20801,
+    IT: 22201,
+    ES: 21401,
+};
+export const PREFERRED_PLMN_FALLBACK = 24001;
+export function normalizeCountryIso2(code) {
+    if (code == null || typeof code !== 'string')
+        return null;
+    const t = code.trim().toUpperCase();
+    if (!/^[A-Z]{2}$/.test(t))
+        return null;
+    return t;
+}
+export function resolveSetOperator(arg) {
+    const raw = String(arg ?? '').trim();
+    if (!raw || raw.toUpperCase() === 'AUTO')
+        return { mode: 'AUTO' };
+    const iso = normalizeCountryIso2(raw);
+    if (!iso)
+        throw new Error(`Invalid country ISO: ${raw}`);
+    const plmn = PREFERRED_PLMN_BY_COUNTRY_ISO2[iso] ?? PREFERRED_PLMN_FALLBACK;
+    return { mode: 'VALUE', plmn, countryIso: iso };
+}

package/dist/plmn-labels.d.ts

@@ -0,0 +1,14 @@
+/**
+ * NB-IoT PLMN → operator label. Keep in sync with app `src/lib/plmn-options.ts`.
+ */
+export type TempivoPlmnOperatorOption = {
+    plmn: number;
+    label: string;
+};
+/** Known operators (same labels as Tempivo settings / BLE strip). */
+export declare const PLMN_OPERATOR_LABELS: TempivoPlmnOperatorOption[];
+/**
+ * Operator name from PLMN. Known codes return labels (e.g. Tele2 Sweden).
+ * Unknown but valid codes return `PLMN {code}` so partners still see something.
+ */
+export declare function getOperatorNameFromPlmn(plmn: number | null | undefined): string | null;

package/dist/plmn-labels.js

@@ -0,0 +1,37 @@
+/**
+ * NB-IoT PLMN → operator label. Keep in sync with app `src/lib/plmn-options.ts`.
+ */
+/** Known operators (same labels as Tempivo settings / BLE strip). */
+export const PLMN_OPERATOR_LABELS = [
+    { plmn: 24001, label: 'Telia Sweden' },
+    { plmn: 24007, label: 'Tele2 Sweden' },
+    { plmn: 24008, label: 'Telenor Sweden' },
+    { plmn: 24002, label: '3 Sweden' },
+    { plmn: 24201, label: 'Telenor Norway' },
+    { plmn: 24202, label: 'Telia Norway' },
+    { plmn: 23801, label: 'TDC Denmark' },
+    { plmn: 23820, label: 'Telia Denmark' },
+    { plmn: 24491, label: 'Telia Finland' },
+    { plmn: 24405, label: 'Elisa Finland' },
+    { plmn: 23420, label: '3 UK' },
+    { plmn: 23410, label: 'O2 UK' },
+    { plmn: 23415, label: 'Vodafone UK' },
+    { plmn: 26201, label: 'T-Mobile Germany' },
+    { plmn: 26202, label: 'Vodafone Germany' },
+    { plmn: 26207, label: 'O2 Germany' },
+    { plmn: 20801, label: 'Orange France' },
+    { plmn: 20810, label: 'SFR France' },
+    { plmn: 22201, label: 'TIM Italy' },
+    { plmn: 21401, label: 'Vodafone Spain' },
+];
+const PLMN_TO_LABEL = Object.fromEntries(PLMN_OPERATOR_LABELS.map((o) => [o.plmn, o.label]));
+/**
+ * Operator name from PLMN. Known codes return labels (e.g. Tele2 Sweden).
+ * Unknown but valid codes return `PLMN {code}` so partners still see something.
+ */
+export function getOperatorNameFromPlmn(plmn) {
+    const n = plmn != null ? Number(plmn) : NaN;
+    if (!Number.isFinite(n) || n < 10_000 || n > 999_999)
+        return null;
+    return PLMN_TO_LABEL[n] ?? `PLMN ${Math.trunc(n)}`;
+}