@tempivo/sensor-beacon 1.1.1 → 1.1.4

package/android-aar/library/src/test/java/com/tempivo/sensor/beacon/PartnerBleRulesTest.kt

@@ -0,0 +1,209 @@
+package com.tempivo.sensor.beacon
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import pl.efento.mobile.bluetooth.model.sensor.Action
+import pl.efento.mobile.bluetooth.model.sensor.DisabledCondition
+import pl.efento.mobile.bluetooth.model.sensor.HighThresholdCondition
+import pl.efento.mobile.bluetooth.model.sensor.LogicOperator
+import pl.efento.mobile.bluetooth.model.sensor.LogicOperatorCondition
+import pl.efento.mobile.bluetooth.model.sensor.LowThresholdCondition
+import pl.efento.mobile.bluetooth.model.sensor.Rule
+
+class PartnerBleRulesTest {
+    private val simon =
+        TempivoSensorConfiguration(
+            temperatureAlerts =
+                listOf(
+                    TempivoTemperatureAlert(
+                        type = "range",
+                        channel = "ambient",
+                        lowC = 2.0,
+                        highC = 8.0,
+                        hysteresisC = 0.5,
+                        transmitOnBreach = true,
+                        transmitOnReturn = true,
+                    ),
+                    TempivoTemperatureAlert(
+                        type = "range",
+                        channel = "probe",
+                        lowC = -30.0,
+                        highC = -18.0,
+                        hysteresisC = 0.5,
+                        transmitOnBreach = true,
+                        transmitOnReturn = true,
+                    ),
+                ),
+            schedule = TempivoSchedule(always = true),
+            measurementIntervalMinutes = 5.0,
+            transmissionIntervalSeconds = 3600,
+        )
+
+    @Test
+    fun compileDecompileSimonJsonKeepsBothRanges() {
+        val (rules, _) = PartnerBleRules.compile(simon)
+        val kinds = rules.take(6).map { kind(it) }
+        assertEquals(listOf("LOW", "HIGH", "OR", "LOW", "HIGH", "OR"), kinds)
+
+        val got = PartnerBleRules.decompile(rules)
+        assertEquals(2, got.temperatureAlerts.size)
+        assertEquals("ambient", got.temperatureAlerts[0].channel)
+        assertEquals(2.0, got.temperatureAlerts[0].lowC!!, 0.01)
+        assertEquals(8.0, got.temperatureAlerts[0].highC!!, 0.01)
+        assertEquals("probe", got.temperatureAlerts[1].channel)
+        assertEquals(-30.0, got.temperatureAlerts[1].lowC!!, 0.01)
+        assertEquals(-18.0, got.temperatureAlerts[1].highC!!, 0.01)
+        assertTrue(got.temperatureAlerts.all { it.transmitOnReturn })
+    }
+
+    @Test
+    fun setSameJsonTwiceIsAccepted() {
+        val (rules, _) = PartnerBleRules.compile(simon)
+        val empty = List(12) { i -> Rule(i + 1, emptySet(), DisabledCondition, Action.NO_ACTION) }
+
+        val first = PartnerBleRules.configurationWriteAccepted(simon.temperatureAlerts, rules, empty, rules)
+        assertTrue(first)
+
+        val second = PartnerBleRules.configurationWriteAccepted(simon.temperatureAlerts, rules, rules, rules)
+        assertTrue(second)
+    }
+
+    @Test
+    fun oldReadbackCountCheckFailsWhenDecompileIsEmpty() {
+        val (rules, _) = PartnerBleRules.compile(simon)
+        val emptyGet = PartnerBleRules.decompile(emptyList()).temperatureAlerts
+        assertEquals(0, emptyGet.size)
+        assertTrue(emptyGet.size < simon.temperatureAlerts.size)
+    }
+
+    @Test
+    fun liveDeskProtoDecompilesAndIdempotentSetIsAccepted() {
+        // Live get from desk sensor after Simon JSON (channel_mask 1 / 4, 0.1 °C units).
+        val fromDevice =
+            listOf(
+                threshold(1, 1, true, 2.0, 0.5, Action.NO_ACTION),
+                threshold(2, 1, false, 8.0, 0.5, Action.NO_ACTION),
+                orSlot(3, setOf(1, 2)),
+                threshold(4, 3, true, -30.0, 0.5, Action.NO_ACTION),
+                threshold(5, 3, false, -18.0, 0.5, Action.NO_ACTION),
+                orSlot(6, setOf(4, 5)),
+            ) + List(6) { i -> Rule(i + 7, emptySet(), DisabledCondition, Action.NO_ACTION) }
+
+        val got = PartnerBleRules.decompile(fromDevice)
+        assertEquals(2, got.temperatureAlerts.size)
+        assertEquals(listOf("ambient", "probe"), got.temperatureAlerts.map { it.channel })
+
+        val (intended, _) = PartnerBleRules.compile(simon)
+        assertTrue(PartnerBleRules.compiledRulesMatchDevice(intended, fromDevice))
+        assertTrue(
+            PartnerBleRules.configurationWriteAccepted(
+                simon.temperatureAlerts,
+                intended,
+                fromDevice,
+                fromDevice,
+            ),
+        )
+    }
+
+    @Test
+    fun zeroBasedSlotsDecompileToAmbientAndProbe() {
+        val fromDevice =
+            listOf(
+                threshold(1, 0, true, 2.0, 0.5, Action.NO_ACTION),
+                threshold(2, 0, false, 8.0, 0.5, Action.NO_ACTION),
+                orSlot(3, setOf(1, 2)),
+                threshold(4, 2, true, -30.0, 0.5, Action.NO_ACTION),
+                threshold(5, 2, false, -18.0, 0.5, Action.NO_ACTION),
+                orSlot(6, setOf(4, 5)),
+            ) + List(6) { i -> Rule(i + 7, emptySet(), DisabledCondition, Action.NO_ACTION) }
+        val got = PartnerBleRules.decompile(fromDevice)
+        assertEquals(2, got.temperatureAlerts.size)
+        assertEquals(listOf("ambient", "probe"), got.temperatureAlerts.map { it.channel })
+    }
+
+    @Test
+    fun fw7ExtraRuleSlotsStillDecompileById() {
+        val active =
+            listOf(
+                threshold(1, 1, true, 2.0, 0.5, Action.NO_ACTION),
+                threshold(2, 1, false, 8.0, 0.5, Action.NO_ACTION),
+                orSlot(3, setOf(1, 2)),
+                threshold(4, 3, true, -30.0, 0.5, Action.NO_ACTION),
+                threshold(5, 3, false, -18.0, 0.5, Action.NO_ACTION),
+                orSlot(6, setOf(4, 5)),
+            )
+        // Simulate FW7 returning >12 entries: padding first, then real ids.
+        val padding = List(12) { i -> Rule(100 + i, emptySet(), DisabledCondition, Action.NO_ACTION) }
+        val fromDevice = padding + active
+        val got = PartnerBleRules.decompile(fromDevice)
+        assertEquals(2, got.temperatureAlerts.size)
+        assertEquals(listOf("ambient", "probe"), got.temperatureAlerts.map { it.channel })
+    }
+
+    @Test
+    fun emptyGetAfterSameConfigIsStillAccepted() {
+        val (rules, _) = PartnerBleRules.compile(simon)
+        val empty = List(12) { i -> Rule(i + 1, emptySet(), DisabledCondition, Action.NO_ACTION) }
+        assertTrue(
+            PartnerBleRules.configurationWriteAccepted(simon.temperatureAlerts, rules, rules, empty),
+        )
+        // Blind HC7 get (empty before and after) must not reject a successful write.
+        assertTrue(
+            PartnerBleRules.configurationWriteAccepted(simon.temperatureAlerts, rules, empty, empty),
+        )
+    }
+
+    private fun threshold(
+        id: Int,
+        channel: Int,
+        low: Boolean,
+        t: Double,
+        hyst: Double,
+        action: Action,
+    ): Rule {
+        val params =
+            pl.efento.mobile.bluetooth.model.sensor.TemperatureLowHighThresholdConditionParameters(
+                t,
+                hyst,
+                pl.efento.mobile.bluetooth.model.sensor.TriggeringMode.CONSECUTIVE_SAMPLES,
+                1,
+            )
+        val condition =
+            if (low) {
+                pl.efento.mobile.bluetooth.model.sensor.LowThresholdCondition(params)
+            } else {
+                pl.efento.mobile.bluetooth.model.sensor.HighThresholdCondition(params)
+            }
+        return Rule(id, setOf(channel), condition, action)
+    }
+
+    private fun orSlot(id: Int, selected: Set<Int>): Rule =
+        Rule(
+            id,
+            emptySet(),
+            pl.efento.mobile.bluetooth.model.sensor.LogicOperatorCondition(
+                pl.efento.mobile.bluetooth.model.sensor.LogicOperatorConditionParameters(
+                    LogicOperator.OR,
+                    selected,
+                    emptySet(),
+                    0,
+                    0,
+                ),
+            ),
+            Action.TRIGGER_TRANSMISSION_WITH_ACK,
+        )
+
+    private fun kind(rule: Rule): String =
+        when (rule.condition) {
+            is LowThresholdCondition -> "LOW"
+            is HighThresholdCondition -> "HIGH"
+            is LogicOperatorCondition -> {
+                val p = (rule.condition as LogicOperatorCondition).conditionParameters
+                if (p.logicOperator == LogicOperator.OR) "OR" else "LOGIC"
+            }
+            is DisabledCondition -> "OFF"
+            else -> rule.condition.javaClass.simpleName
+        }
+}

package/dist/native-helpers.js

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

package/dist/native-module.d.ts

@@ -8,7 +8,17 @@ 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>;
+/**
+ * Partner configuration from the device.
+ * Return shape is only {@link TempivoSensorConfiguration} (no debug fields).
+ * iOS and Android use raw ProtoConfig GATT; return shape is only partner fields.
+ */
 export declare function getConfiguration(): Promise<TempivoSensorConfiguration>;
+/**
+ * Write partner configuration to the device.
+ * Same public signature as before. Encodes partner config to ProtoConfig and writes raw GATT
+ * when `writeProtoConfigBase64` is available (iOS and Android).
+ */
 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

@@ -1,7 +1,9 @@
 import { requireOptionalNativeModule } from 'expo-modules-core';
 import { TempivoSensorError } from './errors.js';
 import { configToJson, mapNativeError, qrToConnectJson } from './native-helpers.js';
-import { parseSensorConfigurationFromDeviceJson } from './profile.js';
+import { partnerConfigFromProtoBase64 } from './proto/partner-from-proto.js';
+import { partnerConfigToProtoBase64 } from './proto/partner-to-proto.js';
+import { parseSensorConfigurationFromDevice } from './profile.js';
 function getNative() {
     const native = requireOptionalNativeModule('TempivoSensorBeacon');
     if (!native) {
@@ -67,24 +69,65 @@ export async function connect(qr) {
 }
 export async function disconnect() {
     try {
+        lastProtoBase64 = null;
         await getNative().disconnect();
     }
     catch (error) {
         throw mapNativeError(error);
     }
 }
+/** Last ProtoConfig from iOS raw get; used as set baseline. Not part of the partner API. */
+let lastProtoBase64 = null;
+/**
+ * Partner configuration from the device.
+ * Return shape is only {@link TempivoSensorConfiguration} (no debug fields).
+ * iOS and Android use raw ProtoConfig GATT; return shape is only partner fields.
+ */
 export async function getConfiguration() {
     try {
         const json = await getNative().getConfigurationJson();
-        return parseSensorConfigurationFromDeviceJson(json);
+        const parsed = JSON.parse(json);
+        const protoB64 = typeof parsed.protoBase64 === 'string' ? parsed.protoBase64 : null;
+        if (protoB64) {
+            lastProtoBase64 = protoB64;
+            return partnerConfigFromProtoBase64(protoB64);
+        }
+        lastProtoBase64 = null;
+        return parseSensorConfigurationFromDevice(parsed);
     }
     catch (error) {
         throw mapNativeError(error);
     }
 }
+/**
+ * Write partner configuration to the device.
+ * Same public signature as before. Encodes partner config to ProtoConfig and writes raw GATT
+ * when `writeProtoConfigBase64` is available (iOS and Android).
+ */
 export async function setConfigurationJson(config) {
     try {
-        await getNative().setConfigurationJson(configToJson(config));
+        const partner = typeof config === 'string'
+            ? JSON.parse(config)
+            : config;
+        const native = getNative();
+        if (typeof native.writeProtoConfigBase64 === 'function') {
+            let baseline = lastProtoBase64;
+            if (!baseline) {
+                await getConfiguration();
+                baseline = lastProtoBase64;
+            }
+            if (!baseline) {
+                throw new TempivoSensorError('invalidConfig', 'Cannot set: missing baseline ProtoConfig from device get.');
+            }
+            const nextB64 = partnerConfigToProtoBase64(partner, baseline);
+            await native.writeProtoConfigBase64(nextB64);
+            lastProtoBase64 = nextB64;
+            return;
+        }
+        if (typeof native.setConfigurationJson !== 'function') {
+            throw new TempivoSensorError('runtimeUnavailable', 'Native setConfigurationJson is unavailable in this build.');
+        }
+        await native.setConfigurationJson(configToJson(partner));
     }
     catch (error) {
         throw mapNativeError(error);

package/dist/partner-dual-range-fixture.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Partner BLE dual-range + always payload used in regression tests.
+ * Before SDK 1.1.2, get could return empty alerts and/or Sunday-only schedule.
+ */
+export declare const PARTNER_DUAL_RANGE_ALWAYS_BODY: {
+    schedule: {
+        always: boolean;
+    };
+    temperatureAlerts: ({
+        type: "range";
+        channel: "ambient";
+        lowC: number;
+        highC: number;
+        hysteresisC: number;
+        transmitOnBreach: boolean;
+        transmitOnReturn: boolean;
+    } | {
+        type: "range";
+        channel: "probe";
+        lowC: number;
+        highC: number;
+        hysteresisC: number;
+        transmitOnBreach: boolean;
+        transmitOnReturn: boolean;
+    })[];
+    measurementIntervalMinutes: number;
+    transmissionIntervalSeconds: number;
+};

package/dist/partner-dual-range-fixture.js

@@ -0,0 +1,29 @@
+/**
+ * Partner BLE dual-range + always payload used in regression tests.
+ * Before SDK 1.1.2, get could return empty alerts and/or Sunday-only schedule.
+ */
+export const PARTNER_DUAL_RANGE_ALWAYS_BODY = {
+    schedule: { always: true },
+    temperatureAlerts: [
+        {
+            type: 'range',
+            channel: 'ambient',
+            lowC: 2,
+            highC: 8,
+            hysteresisC: 0.5,
+            transmitOnBreach: true,
+            transmitOnReturn: true,
+        },
+        {
+            type: 'range',
+            channel: 'probe',
+            lowC: -30,
+            highC: -18,
+            hysteresisC: 0.5,
+            transmitOnBreach: true,
+            transmitOnReturn: true,
+        },
+    ],
+    measurementIntervalMinutes: 5,
+    transmissionIntervalSeconds: 3600,
+};

package/dist/profile.js

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

package/dist/proto/decode-proto-config.d.ts

@@ -0,0 +1,3 @@
+export type ProtoConfigObject = Record<string, unknown>;
+export declare function decodeProtoConfigBytes(bytes: Uint8Array): ProtoConfigObject;
+export declare function decodeProtoConfigBase64(b64: string): ProtoConfigObject;

package/dist/proto/decode-proto-config.js

@@ -0,0 +1,46 @@
+/**
+ * Decode Efento ProtoConfig bytes (same descriptor as web bluetooth module).
+ */
+import protobuf from 'protobufjs/light.js';
+import descriptor from './efento-protobuf-descriptor.js';
+const root = protobuf.Root.fromJSON(descriptor);
+const ProtoConfig = root.lookupType('ProtoConfig');
+export function decodeProtoConfigBytes(bytes) {
+    const msg = ProtoConfig.decode(bytes);
+    return ProtoConfig.toObject(msg, {
+        enums: String,
+        longs: Number,
+        bytes: Array,
+        arrays: true,
+        objects: true,
+        oneofs: true,
+    });
+}
+function base64ToBytes(b64) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    const clean = b64.replace(/=+$/, '').replace(/[^A-Za-z0-9+/]/g, '');
+    const out = new Uint8Array((clean.length * 3) >> 2);
+    let o = 0;
+    for (let i = 0; i < clean.length; i += 4) {
+        const a = chars.indexOf(clean[i] ?? 'A');
+        const b = chars.indexOf(clean[i + 1] ?? 'A');
+        const c = chars.indexOf(clean[i + 2] ?? 'A');
+        const d = chars.indexOf(clean[i + 3] ?? 'A');
+        out[o++] = (a << 2) | (b >> 4);
+        if (clean[i + 2] != null)
+            out[o++] = ((b & 15) << 4) | (c >> 2);
+        if (clean[i + 3] != null)
+            out[o++] = ((c & 3) << 6) | d;
+    }
+    return out.subarray(0, o);
+}
+export function decodeProtoConfigBase64(b64) {
+    if (typeof atob === 'function') {
+        const binary = atob(b64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++)
+            bytes[i] = binary.charCodeAt(i);
+        return decodeProtoConfigBytes(bytes);
+    }
+    return decodeProtoConfigBytes(base64ToBytes(b64));
+}