brilliantsole 0.0.25 → 0.0.27

package/build/brilliantsole.module.js

@@ -54,7 +54,7 @@ var environment = /*#__PURE__*/Object.freeze({
     isSafari: isSafari
 });
 
-var _a$5, _Console_consoles, _Console_levelFlags;
+var _a$6, _Console_consoles, _Console_levelFlags;
 var __console;
 if (isInLensStudio) {
     const log = function (...args) {
@@ -97,27 +97,27 @@ class Console {
             error: true,
             table: true,
         });
-        if (__classPrivateFieldGet(_a$5, _a$5, "f", _Console_consoles)[type]) {
+        if (__classPrivateFieldGet(_a$6, _a$6, "f", _Console_consoles)[type]) {
             throw new Error(`"${type}" console already exists`);
         }
-        __classPrivateFieldGet(_a$5, _a$5, "f", _Console_consoles)[type] = this;
+        __classPrivateFieldGet(_a$6, _a$6, "f", _Console_consoles)[type] = this;
     }
     setLevelFlags(levelFlags) {
         Object.assign(__classPrivateFieldGet(this, _Console_levelFlags, "f"), levelFlags);
     }
     static setLevelFlagsForType(type, levelFlags) {
-        if (!__classPrivateFieldGet(this, _a$5, "f", _Console_consoles)[type]) {
+        if (!__classPrivateFieldGet(this, _a$6, "f", _Console_consoles)[type]) {
             throw new Error(`no console found with type "${type}"`);
         }
-        __classPrivateFieldGet(this, _a$5, "f", _Console_consoles)[type].setLevelFlags(levelFlags);
+        __classPrivateFieldGet(this, _a$6, "f", _Console_consoles)[type].setLevelFlags(levelFlags);
     }
     static setAllLevelFlags(levelFlags) {
-        for (const type in __classPrivateFieldGet(this, _a$5, "f", _Console_consoles)) {
-            __classPrivateFieldGet(this, _a$5, "f", _Console_consoles)[type].setLevelFlags(levelFlags);
+        for (const type in __classPrivateFieldGet(this, _a$6, "f", _Console_consoles)) {
+            __classPrivateFieldGet(this, _a$6, "f", _Console_consoles)[type].setLevelFlags(levelFlags);
         }
     }
     static create(type, levelFlags) {
-        const console = __classPrivateFieldGet(this, _a$5, "f", _Console_consoles)[type] || new _a$5(type);
+        const console = __classPrivateFieldGet(this, _a$6, "f", _Console_consoles)[type] || new _a$6(type);
         return console;
     }
     get log() {
@@ -147,7 +147,7 @@ class Console {
         this.assertWithError(enumeration.includes(value), `invalid enum "${value}"`);
     }
 }
-_a$5 = Console, _Console_levelFlags = new WeakMap();
+_a$6 = Console, _Console_levelFlags = new WeakMap();
 _Console_consoles = { value: {} };
 function createConsole(type, levelFlags) {
     return Console.create(type, levelFlags);
@@ -325,7 +325,7 @@ class Timer {
 }
 _Timer_callback = new WeakMap(), _Timer_interval = new WeakMap(), _Timer_intervalId = new WeakMap();
 
-createConsole("checksum", { log: true });
+createConsole("checksum", { log: false });
 function crc32ForByte(r) {
     for (let j = 0; j < 8; ++j) {
         r = (r & 1 ? 0 : 0xedb88320) ^ (r >>> 1);
@@ -500,8 +500,8 @@ function autoBind(self, {include, exclude} = {}) {
 	return self;
 }
 
-var _FileTransferManager_instances, _a$4, _FileTransferManager_dispatchEvent_get, _FileTransferManager_assertValidType, _FileTransferManager_assertValidTypeEnum, _FileTransferManager_assertValidStatusEnum, _FileTransferManager_assertValidCommand, _FileTransferManager_MaxLength, _FileTransferManager_maxLength, _FileTransferManager_parseMaxLength, _FileTransferManager_updateMaxLength, _FileTransferManager_assertValidLength, _FileTransferManager_type, _FileTransferManager_parseType, _FileTransferManager_updateType, _FileTransferManager_setType, _FileTransferManager_length, _FileTransferManager_parseLength, _FileTransferManager_updateLength, _FileTransferManager_setLength, _FileTransferManager_checksum, _FileTransferManager_parseChecksum, _FileTransferManager_updateChecksum, _FileTransferManager_setChecksum, _FileTransferManager_setCommand, _FileTransferManager_status, _FileTransferManager_parseStatus, _FileTransferManager_updateStatus, _FileTransferManager_assertIsIdle, _FileTransferManager_assertIsNotIdle, _FileTransferManager_receivedBlocks, _FileTransferManager_parseBlock, _FileTransferManager_buffer, _FileTransferManager_bytesTransferred, _FileTransferManager_send, _FileTransferManager_sendBlock, _FileTransferManager_parseBytesTransferred, _FileTransferManager_isServerSide;
-const _console$s = createConsole("FileTransferManager", { log: true });
+var _FileTransferManager_instances, _a$5, _FileTransferManager_dispatchEvent_get, _FileTransferManager_assertValidType, _FileTransferManager_assertValidTypeEnum, _FileTransferManager_assertValidStatusEnum, _FileTransferManager_assertValidCommand, _FileTransferManager_MaxLength, _FileTransferManager_maxLength, _FileTransferManager_parseMaxLength, _FileTransferManager_updateMaxLength, _FileTransferManager_assertValidLength, _FileTransferManager_type, _FileTransferManager_parseType, _FileTransferManager_updateType, _FileTransferManager_setType, _FileTransferManager_length, _FileTransferManager_parseLength, _FileTransferManager_updateLength, _FileTransferManager_setLength, _FileTransferManager_checksum, _FileTransferManager_parseChecksum, _FileTransferManager_updateChecksum, _FileTransferManager_setChecksum, _FileTransferManager_setCommand, _FileTransferManager_status, _FileTransferManager_parseStatus, _FileTransferManager_updateStatus, _FileTransferManager_assertIsIdle, _FileTransferManager_assertIsNotIdle, _FileTransferManager_receivedBlocks, _FileTransferManager_parseBlock, _FileTransferManager_buffer, _FileTransferManager_bytesTransferred, _FileTransferManager_send, _FileTransferManager_sendBlock, _FileTransferManager_parseBytesTransferred, _FileTransferManager_isServerSide;
+const _console$s = createConsole("FileTransferManager", { log: false });
 const FileTransferMessageTypes = [
     "maxFileLength",
     "getFileType",
@@ -529,7 +529,7 @@ const FileTransferEventTypes = [
 class FileTransferManager {
     constructor() {
         _FileTransferManager_instances.add(this);
-        _FileTransferManager_maxLength.set(this, _a$4.MaxLength);
+        _FileTransferManager_maxLength.set(this, _a$5.MaxLength);
         _FileTransferManager_type.set(this, void 0);
         _FileTransferManager_length.set(this, 0);
         _FileTransferManager_checksum.set(this, 0);
@@ -550,7 +550,7 @@ class FileTransferManager {
         return this.eventDispatcher.waitForEvent;
     }
     static get MaxLength() {
-        return __classPrivateFieldGet(this, _a$4, "f", _FileTransferManager_MaxLength);
+        return __classPrivateFieldGet(this, _a$5, "f", _FileTransferManager_MaxLength);
     }
     get maxLength() {
         return __classPrivateFieldGet(this, _FileTransferManager_maxLength, "f");
@@ -636,7 +636,7 @@ class FileTransferManager {
         __classPrivateFieldSet(this, _FileTransferManager_isServerSide, newIsServerSide, "f");
     }
 }
-_a$4 = FileTransferManager, _FileTransferManager_maxLength = new WeakMap(), _FileTransferManager_type = new WeakMap(), _FileTransferManager_length = new WeakMap(), _FileTransferManager_checksum = new WeakMap(), _FileTransferManager_status = new WeakMap(), _FileTransferManager_receivedBlocks = new WeakMap(), _FileTransferManager_buffer = new WeakMap(), _FileTransferManager_bytesTransferred = new WeakMap(), _FileTransferManager_isServerSide = new WeakMap(), _FileTransferManager_instances = new WeakSet(), _FileTransferManager_dispatchEvent_get = function _FileTransferManager_dispatchEvent_get() {
+_a$5 = FileTransferManager, _FileTransferManager_maxLength = new WeakMap(), _FileTransferManager_type = new WeakMap(), _FileTransferManager_length = new WeakMap(), _FileTransferManager_checksum = new WeakMap(), _FileTransferManager_status = new WeakMap(), _FileTransferManager_receivedBlocks = new WeakMap(), _FileTransferManager_buffer = new WeakMap(), _FileTransferManager_bytesTransferred = new WeakMap(), _FileTransferManager_isServerSide = new WeakMap(), _FileTransferManager_instances = new WeakSet(), _FileTransferManager_dispatchEvent_get = function _FileTransferManager_dispatchEvent_get() {
     return this.eventDispatcher.dispatchEvent;
 }, _FileTransferManager_assertValidType = function _FileTransferManager_assertValidType(type) {
     _console$s.assertEnumWithError(type, FileTypes);
@@ -826,7 +826,7 @@ _a$4 = FileTransferManager, _FileTransferManager_maxLength = new WeakMap(), _Fil
 };
 _FileTransferManager_MaxLength = { value: 0 };
 
-const _console$r = createConsole("MathUtils", { log: true });
+const _console$r = createConsole("MathUtils", { log: false });
 function getInterpolation(value, min, max, span) {
     if (span == undefined) {
         span = max - min;
@@ -914,15 +914,15 @@ class CenterOfPressureHelper {
         __classPrivateFieldGet(this, _CenterOfPressureHelper_range, "f").x.update(centerOfPressure.x);
         __classPrivateFieldGet(this, _CenterOfPressureHelper_range, "f").y.update(centerOfPressure.y);
     }
-    getNormalization(centerOfPressure) {
+    getNormalization(centerOfPressure, weightByRange) {
         return {
-            x: __classPrivateFieldGet(this, _CenterOfPressureHelper_range, "f").x.getNormalization(centerOfPressure.x, false),
-            y: __classPrivateFieldGet(this, _CenterOfPressureHelper_range, "f").y.getNormalization(centerOfPressure.y, false),
+            x: __classPrivateFieldGet(this, _CenterOfPressureHelper_range, "f").x.getNormalization(centerOfPressure.x, weightByRange),
+            y: __classPrivateFieldGet(this, _CenterOfPressureHelper_range, "f").y.getNormalization(centerOfPressure.y, weightByRange),
         };
     }
-    updateAndGetNormalization(centerOfPressure) {
+    updateAndGetNormalization(centerOfPressure, weightByRange) {
         this.update(centerOfPressure);
-        return this.getNormalization(centerOfPressure);
+        return this.getNormalization(centerOfPressure, weightByRange);
     }
 }
 _CenterOfPressureHelper_range = new WeakMap();
@@ -943,8 +943,8 @@ function arrayWithoutDuplicates(array) {
     return array.filter((value, index) => array.indexOf(value) == index);
 }
 
-var _PressureSensorDataManager_positions, _PressureSensorDataManager_sensorRangeHelpers, _PressureSensorDataManager_centerOfPressureHelper;
-const _console$q = createConsole("PressureDataManager", { log: true });
+var _PressureSensorDataManager_positions, _PressureSensorDataManager_sensorRangeHelpers, _PressureSensorDataManager_normalizedSumRangeHelper, _PressureSensorDataManager_centerOfPressureHelper;
+const _console$q = createConsole("PressureDataManager", { log: false });
 const PressureSensorTypes = ["pressure"];
 const ContinuousPressureSensorTypes = PressureSensorTypes;
 const DefaultNumberOfPressureSensors = 8;
@@ -952,6 +952,7 @@ class PressureSensorDataManager {
     constructor() {
         _PressureSensorDataManager_positions.set(this, []);
         _PressureSensorDataManager_sensorRangeHelpers.set(this, void 0);
+        _PressureSensorDataManager_normalizedSumRangeHelper.set(this, new RangeHelper());
         _PressureSensorDataManager_centerOfPressureHelper.set(this, new CenterOfPressureHelper());
     }
     get positions() {
@@ -974,37 +975,38 @@ class PressureSensorDataManager {
         this.resetRange();
     }
     resetRange() {
-        __classPrivateFieldGet(this, _PressureSensorDataManager_sensorRangeHelpers, "f").forEach((rangeHelper) => rangeHelper.reset());
+        __classPrivateFieldGet(this, _PressureSensorDataManager_sensorRangeHelpers, "f")?.forEach((rangeHelper) => rangeHelper.reset());
         __classPrivateFieldGet(this, _PressureSensorDataManager_centerOfPressureHelper, "f").reset();
+        __classPrivateFieldGet(this, _PressureSensorDataManager_normalizedSumRangeHelper, "f").reset();
     }
     parseData(dataView, scalar) {
         const pressure = { sensors: [], scaledSum: 0, normalizedSum: 0 };
         for (let index = 0, byteOffset = 0; byteOffset < dataView.byteLength; index++, byteOffset += 2) {
             const rawValue = dataView.getUint16(byteOffset, true);
-            const scaledValue = rawValue * scalar;
+            let scaledValue = (rawValue * scalar) / this.numberOfSensors;
             const rangeHelper = __classPrivateFieldGet(this, _PressureSensorDataManager_sensorRangeHelpers, "f")[index];
-            const normalizedValue = rangeHelper.updateAndGetNormalization(scaledValue, true);
+            const normalizedValue = rangeHelper.updateAndGetNormalization(scaledValue, false);
             const position = this.positions[index];
             pressure.sensors[index] = { rawValue, scaledValue, normalizedValue, position, weightedValue: 0 };
             pressure.scaledSum += scaledValue;
-            pressure.normalizedSum += normalizedValue / this.numberOfSensors;
         }
-        if (pressure.scaledSum > 0 && pressure.normalizedSum > 0.001) {
+        pressure.normalizedSum = __classPrivateFieldGet(this, _PressureSensorDataManager_normalizedSumRangeHelper, "f").updateAndGetNormalization(pressure.scaledSum, false);
+        if (pressure.scaledSum > 0) {
             pressure.center = { x: 0, y: 0 };
             pressure.sensors.forEach((sensor) => {
                 sensor.weightedValue = sensor.scaledValue / pressure.scaledSum;
                 pressure.center.x += sensor.position.x * sensor.weightedValue;
                 pressure.center.y += sensor.position.y * sensor.weightedValue;
             });
-            pressure.normalizedCenter = __classPrivateFieldGet(this, _PressureSensorDataManager_centerOfPressureHelper, "f").updateAndGetNormalization(pressure.center);
+            pressure.normalizedCenter = __classPrivateFieldGet(this, _PressureSensorDataManager_centerOfPressureHelper, "f").updateAndGetNormalization(pressure.center, false);
         }
         _console$q.log({ pressure });
         return pressure;
     }
 }
-_PressureSensorDataManager_positions = new WeakMap(), _PressureSensorDataManager_sensorRangeHelpers = new WeakMap(), _PressureSensorDataManager_centerOfPressureHelper = new WeakMap();
+_PressureSensorDataManager_positions = new WeakMap(), _PressureSensorDataManager_sensorRangeHelpers = new WeakMap(), _PressureSensorDataManager_normalizedSumRangeHelper = new WeakMap(), _PressureSensorDataManager_centerOfPressureHelper = new WeakMap();
 
-const _console$p = createConsole("MotionSensorDataManager", { log: true });
+const _console$p = createConsole("MotionSensorDataManager", { log: false });
 const MotionSensorTypes = [
     "acceleration",
     "gravity",
@@ -1097,7 +1099,7 @@ class MotionSensorDataManager {
 var _BarometerSensorDataManager_instances, _BarometerSensorDataManager_calculcateAltitude;
 const BarometerSensorTypes = ["barometer"];
 const ContinuousBarometerSensorTypes = BarometerSensorTypes;
-const _console$o = createConsole("BarometerSensorDataManager", { log: true });
+const _console$o = createConsole("BarometerSensorDataManager", { log: false });
 class BarometerSensorDataManager {
     constructor() {
         _BarometerSensorDataManager_instances.add(this);
@@ -1121,7 +1123,7 @@ _BarometerSensorDataManager_instances = new WeakSet(), _BarometerSensorDataManag
     return h;
 };
 
-const _console$n = createConsole("ParseUtils", { log: true });
+const _console$n = createConsole("ParseUtils", { log: false });
 function parseStringFromDataView(dataView, byteOffset = 0) {
     const stringLength = dataView.getUint8(byteOffset++);
     const string = textDecoder.decode(dataView.buffer.slice(dataView.byteOffset + byteOffset, dataView.byteOffset + byteOffset + stringLength));
@@ -1151,7 +1153,7 @@ function parseMessage(dataView, messageTypes, callback, context, parseMessageLen
 }
 
 var _SensorDataManager_scalars;
-const _console$m = createConsole("SensorDataManager", { log: true });
+const _console$m = createConsole("SensorDataManager", { log: false });
 const SensorTypes = [...PressureSensorTypes, ...MotionSensorTypes, ...BarometerSensorTypes];
 const ContinuousSensorTypes = [
     ...ContinuousPressureSensorTypes,
@@ -1261,8 +1263,8 @@ class SensorDataManager {
 }
 _SensorDataManager_scalars = new WeakMap();
 
-var _SensorConfigurationManager_instances, _a$3, _SensorConfigurationManager_dispatchEvent_get, _SensorConfigurationManager_availableSensorTypes, _SensorConfigurationManager_assertAvailableSensorType, _SensorConfigurationManager_configuration, _SensorConfigurationManager_updateConfiguration, _SensorConfigurationManager_isRedundant, _SensorConfigurationManager_parse, _SensorConfigurationManager_AssertValidSensorRate, _SensorConfigurationManager_assertValidSensorRate, _SensorConfigurationManager_createData, _SensorConfigurationManager_ZeroSensorConfiguration;
-const _console$l = createConsole("SensorConfigurationManager", { log: true });
+var _SensorConfigurationManager_instances, _a$4, _SensorConfigurationManager_dispatchEvent_get, _SensorConfigurationManager_availableSensorTypes, _SensorConfigurationManager_assertAvailableSensorType, _SensorConfigurationManager_configuration, _SensorConfigurationManager_updateConfiguration, _SensorConfigurationManager_isRedundant, _SensorConfigurationManager_parse, _SensorConfigurationManager_AssertValidSensorRate, _SensorConfigurationManager_assertValidSensorRate, _SensorConfigurationManager_createData, _SensorConfigurationManager_ZeroSensorConfiguration;
+const _console$l = createConsole("SensorConfigurationManager", { log: false });
 const MaxSensorRate = 2 ** 16 - 1;
 const SensorRateStep = 5;
 const SensorConfigurationMessageTypes = ["getSensorConfiguration", "setSensorConfiguration"];
@@ -1299,11 +1301,11 @@ class SensorConfigurationManager {
         await promise;
     }
     static get ZeroSensorConfiguration() {
-        return __classPrivateFieldGet(this, _a$3, "f", _SensorConfigurationManager_ZeroSensorConfiguration);
+        return __classPrivateFieldGet(this, _a$4, "f", _SensorConfigurationManager_ZeroSensorConfiguration);
     }
     get zeroSensorConfiguration() {
         const zeroSensorConfiguration = {};
-        SensorTypes.forEach((sensorType) => {
+        __classPrivateFieldGet(this, _SensorConfigurationManager_availableSensorTypes, "f").forEach((sensorType) => {
             zeroSensorConfiguration[sensorType] = 0;
         });
         return zeroSensorConfiguration;
@@ -1324,12 +1326,12 @@ class SensorConfigurationManager {
         }
     }
 }
-_a$3 = SensorConfigurationManager, _SensorConfigurationManager_availableSensorTypes = new WeakMap(), _SensorConfigurationManager_configuration = new WeakMap(), _SensorConfigurationManager_instances = new WeakSet(), _SensorConfigurationManager_dispatchEvent_get = function _SensorConfigurationManager_dispatchEvent_get() {
+_a$4 = SensorConfigurationManager, _SensorConfigurationManager_availableSensorTypes = new WeakMap(), _SensorConfigurationManager_configuration = new WeakMap(), _SensorConfigurationManager_instances = new WeakSet(), _SensorConfigurationManager_dispatchEvent_get = function _SensorConfigurationManager_dispatchEvent_get() {
     return this.eventDispatcher.dispatchEvent;
 }, _SensorConfigurationManager_assertAvailableSensorType = function _SensorConfigurationManager_assertAvailableSensorType(sensorType) {
     _console$l.assertWithError(__classPrivateFieldGet(this, _SensorConfigurationManager_availableSensorTypes, "f"), "must get initial sensorConfiguration");
     const isSensorTypeAvailable = __classPrivateFieldGet(this, _SensorConfigurationManager_availableSensorTypes, "f")?.includes(sensorType);
-    _console$l.assert(isSensorTypeAvailable, `unavailable sensor type "${sensorType}"`);
+    _console$l.log(isSensorTypeAvailable, `unavailable sensor type "${sensorType}"`);
     return isSensorTypeAvailable;
 }, _SensorConfigurationManager_updateConfiguration = function _SensorConfigurationManager_updateConfiguration(updatedConfiguration) {
     __classPrivateFieldSet(this, _SensorConfigurationManager_configuration, updatedConfiguration, "f");
@@ -1362,7 +1364,7 @@ _a$3 = SensorConfigurationManager, _SensorConfigurationManager_availableSensorTy
     _console$l.assertWithError(sensorRate < MaxSensorRate, `sensorRate must be 0 or greater (got ${sensorRate})`);
     _console$l.assertWithError(sensorRate % SensorRateStep == 0, `sensorRate must be multiple of ${SensorRateStep}`);
 }, _SensorConfigurationManager_assertValidSensorRate = function _SensorConfigurationManager_assertValidSensorRate(sensorRate) {
-    __classPrivateFieldGet(_a$3, _a$3, "m", _SensorConfigurationManager_AssertValidSensorRate).call(_a$3, sensorRate);
+    __classPrivateFieldGet(_a$4, _a$4, "m", _SensorConfigurationManager_AssertValidSensorRate).call(_a$4, sensorRate);
 }, _SensorConfigurationManager_createData = function _SensorConfigurationManager_createData(sensorConfiguration) {
     let sensorTypes = Object.keys(sensorConfiguration);
     sensorTypes = sensorTypes.filter((sensorType) => __classPrivateFieldGet(this, _SensorConfigurationManager_instances, "m", _SensorConfigurationManager_assertAvailableSensorType).call(this, sensorType));
@@ -1381,12 +1383,12 @@ _a$3 = SensorConfigurationManager, _SensorConfigurationManager_availableSensorTy
 _SensorConfigurationManager_ZeroSensorConfiguration = { value: {} };
 (() => {
     SensorTypes.forEach((sensorType) => {
-        __classPrivateFieldGet(_a$3, _a$3, "f", _SensorConfigurationManager_ZeroSensorConfiguration)[sensorType] = 0;
+        __classPrivateFieldGet(_a$4, _a$4, "f", _SensorConfigurationManager_ZeroSensorConfiguration)[sensorType] = 0;
     });
 })();
 
 var _TfliteManager_instances, _TfliteManager_assertValidTask, _TfliteManager_assertValidTaskEnum, _TfliteManager_dispatchEvent_get, _TfliteManager_name, _TfliteManager_parseName, _TfliteManager_updateName, _TfliteManager_task, _TfliteManager_parseTask, _TfliteManager_updateTask, _TfliteManager_sampleRate, _TfliteManager_parseSampleRate, _TfliteManager_updateSampleRate, _TfliteManager_sensorTypes, _TfliteManager_parseSensorTypes, _TfliteManager_updateSensorTypes, _TfliteManager_isReady, _TfliteManager_parseIsReady, _TfliteManager_updateIsReady, _TfliteManager_assertIsReady, _TfliteManager_captureDelay, _TfliteManager_parseCaptureDelay, _TfliteManager_updateCaptueDelay, _TfliteManager_threshold, _TfliteManager_parseThreshold, _TfliteManager_updateThreshold, _TfliteManager_inferencingEnabled, _TfliteManager_parseInferencingEnabled, _TfliteManager_updateInferencingEnabled, _TfliteManager_parseInference;
-const _console$k = createConsole("TfliteManager", { log: true });
+const _console$k = createConsole("TfliteManager", { log: false });
 const TfliteMessageTypes = [
     "getTfliteName",
     "setTfliteName",
@@ -1721,7 +1723,7 @@ _TfliteManager_name = new WeakMap(), _TfliteManager_task = new WeakMap(), _Tflit
 };
 
 var _DeviceInformationManager_instances, _DeviceInformationManager_dispatchEvent_get, _DeviceInformationManager_information, _DeviceInformationManager_isComplete_get, _DeviceInformationManager_update;
-const _console$j = createConsole("DeviceInformationManager", { log: true });
+const _console$j = createConsole("DeviceInformationManager", { log: false });
 const DeviceInformationMessageTypes = [
     "manufacturerName",
     "modelNumber",
@@ -1796,7 +1798,7 @@ class DeviceInformationManager {
 _DeviceInformationManager_information = new WeakMap(), _DeviceInformationManager_instances = new WeakSet(), _DeviceInformationManager_dispatchEvent_get = function _DeviceInformationManager_dispatchEvent_get() {
     return this.eventDispatcher.dispatchEvent;
 }, _DeviceInformationManager_isComplete_get = function _DeviceInformationManager_isComplete_get() {
-    return DeviceInformationMessageTypes.every((key) => key in __classPrivateFieldGet(this, _DeviceInformationManager_information, "f"));
+    return DeviceInformationMessageTypes.filter((key) => key != "serialNumber").every((key) => key in __classPrivateFieldGet(this, _DeviceInformationManager_information, "f"));
 }, _DeviceInformationManager_update = function _DeviceInformationManager_update(partialDeviceInformation) {
     _console$j.log({ partialDeviceInformation });
     const deviceInformationNames = Object.keys(partialDeviceInformation);
@@ -1814,9 +1816,9 @@ _DeviceInformationManager_information = new WeakMap(), _DeviceInformationManager
 };
 
 var _InformationManager_instances, _InformationManager_dispatchEvent_get, _InformationManager_isCharging, _InformationManager_updateIsCharging, _InformationManager_batteryCurrent, _InformationManager_updateBatteryCurrent, _InformationManager_id, _InformationManager_updateId, _InformationManager_name, _InformationManager_type, _InformationManager_assertValidDeviceType, _InformationManager_assertValidDeviceTypeEnum, _InformationManager_setTypeEnum, _InformationManager_mtu, _InformationManager_updateMtu, _InformationManager_isCurrentTimeSet, _InformationManager_onCurrentTime, _InformationManager_setCurrentTime;
-const _console$i = createConsole("InformationManager", { log: true });
-const DeviceTypes = ["leftInsole", "rightInsole"];
-const InsoleSides = ["left", "right"];
+const _console$i = createConsole("InformationManager", { log: false });
+const DeviceTypes = ["leftInsole", "rightInsole", "leftGlove", "rightGlove", "glasses", "generic"];
+const Sides = ["left", "right"];
 const MinNameLength = 2;
 const MaxNameLength = 30;
 const InformationMessageTypes = [
@@ -1911,12 +1913,25 @@ class InformationManager {
                 return false;
         }
     }
-    get insoleSide() {
+    get isGlove() {
+        switch (this.type) {
+            case "leftGlove":
+            case "rightGlove":
+                return true;
+            default:
+                return false;
+        }
+    }
+    get side() {
         switch (this.type) {
             case "leftInsole":
+            case "leftGlove":
                 return "left";
             case "rightInsole":
+            case "rightGlove":
                 return "right";
+            default:
+                return "left";
         }
     }
     get mtu() {
@@ -1957,7 +1972,10 @@ class InformationManager {
                 this.updateType(type);
                 break;
             case "getMtu":
-                const mtu = dataView.getUint16(0, true);
+                let mtu = dataView.getUint16(0, true);
+                if (isInBrowser) {
+                    mtu = Math.min(mtu, 512);
+                }
                 _console$i.log({ mtu });
                 __classPrivateFieldGet(this, _InformationManager_instances, "m", _InformationManager_updateMtu).call(this, mtu);
                 break;
@@ -2332,8 +2350,8 @@ _VibrationManager_instances = new WeakSet(), _VibrationManager_verifyLocation =
     return data;
 };
 
-var _BaseConnectionManager_instances, _a$2, _BaseConnectionManager_AssertValidTxRxMessageType, _BaseConnectionManager_assertIsSupported, _BaseConnectionManager_status, _BaseConnectionManager_assertIsNotConnected, _BaseConnectionManager_assertIsNotConnecting, _BaseConnectionManager_assertIsConnected, _BaseConnectionManager_assertIsNotDisconnecting, _BaseConnectionManager_assertIsConnectedAndNotDisconnecting, _BaseConnectionManager_pendingMessages, _BaseConnectionManager_isSendingMessages, _BaseConnectionManager_onRxMessage, _BaseConnectionManager_timer, _BaseConnectionManager_checkConnection;
-const _console$g = createConsole("BaseConnectionManager", { log: true });
+var _BaseConnectionManager_instances, _a$3, _BaseConnectionManager_AssertValidTxRxMessageType, _BaseConnectionManager_assertIsSupported, _BaseConnectionManager_status, _BaseConnectionManager_assertIsNotConnected, _BaseConnectionManager_assertIsNotConnecting, _BaseConnectionManager_assertIsConnected, _BaseConnectionManager_assertIsNotDisconnecting, _BaseConnectionManager_assertIsConnectedAndNotDisconnecting, _BaseConnectionManager_pendingMessages, _BaseConnectionManager_isSendingMessages, _BaseConnectionManager_defaultMtu, _BaseConnectionManager_onRxMessage, _BaseConnectionManager_timer, _BaseConnectionManager_checkConnection;
+const _console$g = createConsole("BaseConnectionManager", { log: false });
 const ConnectionStatuses = ["notConnected", "connecting", "connected", "disconnecting"];
 const ConnectionEventTypes = [...ConnectionStatuses, "connectionStatus", "isConnected"];
 const TxRxMessageTypes = [
@@ -2364,6 +2382,9 @@ class BaseConnectionManager {
     get isSupported() {
         return this.baseConstructor.isSupported;
     }
+    get canUpdateFirmware() {
+        return false;
+    }
     get type() {
         return this.baseConstructor.type;
     }
@@ -2372,6 +2393,8 @@ class BaseConnectionManager {
         _BaseConnectionManager_status.set(this, "notConnected");
         _BaseConnectionManager_pendingMessages.set(this, []);
         _BaseConnectionManager_isSendingMessages.set(this, false);
+        _BaseConnectionManager_defaultMtu.set(this, 23);
+        this.mtu = __classPrivateFieldGet(this, _BaseConnectionManager_defaultMtu, "f");
         _BaseConnectionManager_timer.set(this, new Timer(__classPrivateFieldGet(this, _BaseConnectionManager_instances, "m", _BaseConnectionManager_checkConnection).bind(this), 5000));
         __classPrivateFieldGet(this, _BaseConnectionManager_instances, "m", _BaseConnectionManager_assertIsSupported).call(this);
     }
@@ -2394,12 +2417,15 @@ class BaseConnectionManager {
             __classPrivateFieldGet(this, _BaseConnectionManager_timer, "f").stop();
         }
         if (__classPrivateFieldGet(this, _BaseConnectionManager_status, "f") == "notConnected") {
-            this.mtu = undefined;
+            this.mtu = __classPrivateFieldGet(this, _BaseConnectionManager_defaultMtu, "f");
         }
     }
     get isConnected() {
         return this.status == "connected";
     }
+    get isAvailable() {
+        return false;
+    }
     async connect() {
         __classPrivateFieldGet(this, _BaseConnectionManager_instances, "m", _BaseConnectionManager_assertIsNotConnected).call(this);
         __classPrivateFieldGet(this, _BaseConnectionManager_instances, "m", _BaseConnectionManager_assertIsNotConnecting).call(this);
@@ -2434,13 +2460,13 @@ class BaseConnectionManager {
             return;
         }
         if (__classPrivateFieldGet(this, _BaseConnectionManager_isSendingMessages, "f")) {
-            console.log("already sending messages - waiting until later");
+            _console$g.log("already sending messages - waiting until later");
             return;
         }
         __classPrivateFieldSet(this, _BaseConnectionManager_isSendingMessages, true, "f");
         _console$g.log("sendTxMessages", __classPrivateFieldGet(this, _BaseConnectionManager_pendingMessages, "f").slice());
         const arrayBuffers = __classPrivateFieldGet(this, _BaseConnectionManager_pendingMessages, "f").map((message) => {
-            __classPrivateFieldGet(_a$2, _a$2, "m", _BaseConnectionManager_AssertValidTxRxMessageType).call(_a$2, message.type);
+            __classPrivateFieldGet(_a$3, _a$3, "m", _BaseConnectionManager_AssertValidTxRxMessageType).call(_a$3, message.type);
             const messageTypeEnum = TxRxMessageTypes.indexOf(message.type);
             const dataLength = new DataView(new ArrayBuffer(2));
             dataLength.setUint16(0, message.data?.byteLength || 0, true);
@@ -2449,25 +2475,32 @@ class BaseConnectionManager {
         __classPrivateFieldGet(this, _BaseConnectionManager_pendingMessages, "f").length = 0;
         if (this.mtu) {
             while (arrayBuffers.length > 0) {
+                if (arrayBuffers.every((arrayBuffer) => arrayBuffer.byteLength > this.mtu - 3)) {
+                    _console$g.log("every arrayBuffer is too big to send");
+                    break;
+                }
+                _console$g.log("remaining arrayBuffers.length", arrayBuffers.length);
                 let arrayBufferByteLength = 0;
                 let arrayBufferCount = 0;
                 arrayBuffers.some((arrayBuffer) => {
                     if (arrayBufferByteLength + arrayBuffer.byteLength > this.mtu - 3) {
+                        _console$g.log(`stopping appending arrayBuffers ( length ${arrayBuffer.byteLength} too much)`);
                         return true;
                     }
+                    _console$g.log(`allowing arrayBuffer with length ${arrayBuffer.byteLength}`);
                     arrayBufferCount++;
                     arrayBufferByteLength += arrayBuffer.byteLength;
                 });
                 const arrayBuffersToSend = arrayBuffers.splice(0, arrayBufferCount);
                 _console$g.log({ arrayBufferCount, arrayBuffersToSend });
                 const arrayBuffer = concatenateArrayBuffers(...arrayBuffersToSend);
-                _console$g.log("sending arrayBuffer", arrayBuffer);
+                _console$g.log("sending arrayBuffer (partitioned)", arrayBuffer);
                 await this.sendTxData(arrayBuffer);
             }
         }
         else {
             const arrayBuffer = concatenateArrayBuffers(...arrayBuffers);
-            _console$g.log("sending arrayBuffer", arrayBuffer);
+            _console$g.log("sending arrayBuffer (all)", arrayBuffer);
             await this.sendTxData(arrayBuffer);
         }
         __classPrivateFieldSet(this, _BaseConnectionManager_isSendingMessages, false, "f");
@@ -2484,7 +2517,7 @@ class BaseConnectionManager {
         __classPrivateFieldGet(this, _BaseConnectionManager_pendingMessages, "f").length = 0;
     }
 }
-_a$2 = BaseConnectionManager, _BaseConnectionManager_status = new WeakMap(), _BaseConnectionManager_pendingMessages = new WeakMap(), _BaseConnectionManager_isSendingMessages = new WeakMap(), _BaseConnectionManager_timer = new WeakMap(), _BaseConnectionManager_instances = new WeakSet(), _BaseConnectionManager_AssertValidTxRxMessageType = function _BaseConnectionManager_AssertValidTxRxMessageType(messageType) {
+_a$3 = BaseConnectionManager, _BaseConnectionManager_status = new WeakMap(), _BaseConnectionManager_pendingMessages = new WeakMap(), _BaseConnectionManager_isSendingMessages = new WeakMap(), _BaseConnectionManager_defaultMtu = new WeakMap(), _BaseConnectionManager_timer = new WeakMap(), _BaseConnectionManager_instances = new WeakSet(), _BaseConnectionManager_AssertValidTxRxMessageType = function _BaseConnectionManager_AssertValidTxRxMessageType(messageType) {
     _console$g.assertEnumWithError(messageType, TxRxMessageTypes);
 }, _BaseConnectionManager_assertIsSupported = function _BaseConnectionManager_assertIsSupported() {
     _console$g.assertWithError(this.isSupported, `${this.constructor.name} is not supported`);
@@ -2694,12 +2727,15 @@ function getCharacteristicProperties(characteristicName) {
     return properties;
 }
 
-const _console$d = createConsole("BluetoothConnectionManager", { log: true });
+const _console$d = createConsole("BluetoothConnectionManager", { log: false });
 class BluetoothConnectionManager extends BaseConnectionManager {
     constructor() {
         super(...arguments);
         this.isInRange = true;
     }
+    get isAvailable() {
+        return true;
+    }
     onCharacteristicValueChanged(characteristicName, dataView) {
         if (characteristicName == "rx") {
             this.parseRxMessage(dataView);
@@ -2725,7 +2761,7 @@ class BluetoothConnectionManager extends BaseConnectionManager {
 }
 
 var _WebBluetoothConnectionManager_instances, _WebBluetoothConnectionManager_boundBluetoothCharacteristicEventListeners, _WebBluetoothConnectionManager_boundBluetoothDeviceEventListeners, _WebBluetoothConnectionManager_device, _WebBluetoothConnectionManager_services, _WebBluetoothConnectionManager_characteristics, _WebBluetoothConnectionManager_getServicesAndCharacteristics, _WebBluetoothConnectionManager_removeEventListeners, _WebBluetoothConnectionManager_onCharacteristicvaluechanged, _WebBluetoothConnectionManager_onCharacteristicValueChanged, _WebBluetoothConnectionManager_onGattserverdisconnected;
-const _console$c = createConsole("WebBluetoothConnectionManager", { log: true });
+const _console$c = createConsole("WebBluetoothConnectionManager", { log: false });
 var bluetooth;
 if (isInBrowser) {
     bluetooth = window.navigator.bluetooth;
@@ -2747,6 +2783,9 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
     get bluetoothId() {
         return this.device.id;
     }
+    get canUpdateFirmware() {
+        return __classPrivateFieldGet(this, _WebBluetoothConnectionManager_characteristics, "f").has("smp");
+    }
     static get isSupported() {
         return Boolean(bluetooth);
     }
@@ -3307,7 +3346,7 @@ const CBOR = {
   decode,
 };
 
-const _console$b = createConsole("mcumgr", { log: true });
+const _console$b = createConsole("mcumgr", { log: false });
 const constants = {
   MGMT_OP_READ: 0,
   MGMT_OP_READ_RSP: 1,
@@ -3638,7 +3677,7 @@ class MCUManager {
 }
 
 var _FirmwareManager_instances, _FirmwareManager_dispatchEvent_get, _FirmwareManager_status, _FirmwareManager_updateStatus, _FirmwareManager_images, _FirmwareManager_assertImages, _FirmwareManager_assertValidImageIndex, _FirmwareManager_mtu, _FirmwareManager_mcuManager, _FirmwareManager_assignMcuManagerCallbacks, _FirmwareManager_onMcuMessage, _FirmwareManager_onMcuFileDownloadNext, _FirmwareManager_onMcuFileDownloadProgress, _FirmwareManager_onMcuFileDownloadFinished, _FirmwareManager_onMcuFileUploadNext, _FirmwareManager_onMcuFileUploadProgress, _FirmwareManager_onMcuFileUploadFinished, _FirmwareManager_onMcuImageUploadNext, _FirmwareManager_onMcuImageUploadProgress, _FirmwareManager_onMcuImageUploadFinished, _FirmwareManager_onMcuImageState;
-const _console$a = createConsole("FirmwareManager", { log: true });
+const _console$a = createConsole("FirmwareManager", { log: false });
 const FirmwareMessageTypes = ["smp"];
 const FirmwareEventTypes = [
     ...FirmwareMessageTypes,
@@ -3886,7 +3925,7 @@ _FirmwareManager_status = new WeakMap(), _FirmwareManager_images = new WeakMap()
 };
 
 var _DeviceManager_instances, _DeviceManager_boundDeviceEventListeners, _DeviceManager_onDeviceType, _DeviceManager_ConnectedDevices, _DeviceManager_UseLocalStorage, _DeviceManager_DefaultLocalStorageConfiguration, _DeviceManager_LocalStorageConfiguration, _DeviceManager_AssertLocalStorage, _DeviceManager_LocalStorageKey, _DeviceManager_SaveToLocalStorage, _DeviceManager_LoadFromLocalStorage, _DeviceManager_UpdateLocalStorageConfigurationForDevice, _DeviceManager_AvailableDevices, _DeviceManager_EventDispatcher, _DeviceManager_DispatchEvent_get, _DeviceManager_OnDeviceIsConnected, _DeviceManager_DispatchAvailableDevices, _DeviceManager_DispatchConnectedDevices;
-const _console$9 = createConsole("DeviceManager", { log: true });
+const _console$9 = createConsole("DeviceManager", { log: false });
 const DeviceManagerEventTypes = [
     "deviceConnected",
     "deviceDisconnected",
@@ -4028,6 +4067,13 @@ class DeviceManager {
     get RemoveAllEventListeners() {
         return __classPrivateFieldGet(this, _DeviceManager_EventDispatcher, "f").removeAllEventListeners;
     }
+    _CheckDeviceAvailability(device) {
+        if (!device.isConnected && !device.isAvailable && __classPrivateFieldGet(this, _DeviceManager_AvailableDevices, "f").includes(device)) {
+            _console$9.log("removing device from availableDevices...");
+            __classPrivateFieldGet(this, _DeviceManager_AvailableDevices, "f").splice(__classPrivateFieldGet(this, _DeviceManager_AvailableDevices, "f").indexOf(device), 1);
+            __classPrivateFieldGet(this, _DeviceManager_instances, "m", _DeviceManager_DispatchAvailableDevices).call(this);
+        }
+    }
 }
 _DeviceManager_boundDeviceEventListeners = new WeakMap(), _DeviceManager_ConnectedDevices = new WeakMap(), _DeviceManager_UseLocalStorage = new WeakMap(), _DeviceManager_DefaultLocalStorageConfiguration = new WeakMap(), _DeviceManager_LocalStorageConfiguration = new WeakMap(), _DeviceManager_LocalStorageKey = new WeakMap(), _DeviceManager_AvailableDevices = new WeakMap(), _DeviceManager_EventDispatcher = new WeakMap(), _DeviceManager_instances = new WeakSet(), _DeviceManager_onDeviceType = function _DeviceManager_onDeviceType(event) {
     if (__classPrivateFieldGet(this, _DeviceManager_UseLocalStorage, "f")) {
@@ -4129,6 +4175,7 @@ _DeviceManager_boundDeviceEventListeners = new WeakMap(), _DeviceManager_Connect
         }
         __classPrivateFieldGet(this, _DeviceManager_instances, "m", _DeviceManager_DispatchAvailableDevices).call(this);
     }
+    this._CheckDeviceAvailability(device);
 }, _DeviceManager_DispatchAvailableDevices = function _DeviceManager_DispatchAvailableDevices() {
     _console$9.log({ AvailableDevices: this.AvailableDevices });
     __classPrivateFieldGet(this, _DeviceManager_instances, "a", _DeviceManager_DispatchEvent_get).call(this, "availableDevices", { availableDevices: this.AvailableDevices });
@@ -4139,7 +4186,7 @@ _DeviceManager_boundDeviceEventListeners = new WeakMap(), _DeviceManager_Connect
 DeviceManager.shared = new DeviceManager();
 var DeviceManager$1 = DeviceManager.shared;
 
-var _Device_instances, _a$1, _Device_DefaultConnectionManager, _Device_eventDispatcher, _Device_dispatchEvent_get, _Device_connectionManager, _Device_sendTxMessages, _Device_isConnected, _Device_assertIsConnected, _Device_hasRequiredInformation_get, _Device_requestRequiredInformation, _Device_assertCanReconnect, _Device_ReconnectOnDisconnection, _Device_reconnectOnDisconnection, _Device_reconnectIntervalId, _Device_onConnectionStatusUpdated, _Device_dispatchConnectionEvents, _Device_checkConnection, _Device_clear, _Device_onConnectionMessageReceived, _Device_onConnectionMessagesReceived, _Device_deviceInformationManager, _Device_batteryLevel, _Device_updateBatteryLevel, _Device_sensorConfigurationManager, _Device_ClearSensorConfigurationOnLeave, _Device_clearSensorConfigurationOnLeave, _Device_sensorDataManager, _Device_vibrationManager, _Device_fileTransferManager, _Device_tfliteManager, _Device_firmwareManager, _Device_sendSmpMessage, _Device_isServerSide;
+var _Device_instances, _a$2, _Device_DefaultConnectionManager, _Device_eventDispatcher, _Device_dispatchEvent_get, _Device_connectionManager, _Device_sendTxMessages, _Device_isConnected, _Device_assertIsConnected, _Device_hasRequiredInformation_get, _Device_requestRequiredInformation, _Device_assertCanReconnect, _Device_ReconnectOnDisconnection, _Device_reconnectOnDisconnection, _Device_reconnectIntervalId, _Device_onConnectionStatusUpdated, _Device_dispatchConnectionEvents, _Device_checkConnection, _Device_clear, _Device_clearConnection, _Device_onConnectionMessageReceived, _Device_onConnectionMessagesReceived, _Device_deviceInformationManager, _Device_batteryLevel, _Device_updateBatteryLevel, _Device_sensorConfigurationManager, _Device_ClearSensorConfigurationOnLeave, _Device_clearSensorConfigurationOnLeave, _Device_sensorDataManager, _Device_vibrationManager, _Device_fileTransferManager, _Device_tfliteManager, _Device_firmwareManager, _Device_assertCanUpdateFirmware, _Device_sendSmpMessage, _Device_isServerSide;
 const _console$8 = createConsole("Device", { log: true });
 const DeviceEventTypes = [
     "connectionMessage",
@@ -4183,20 +4230,23 @@ class Device {
     get bluetoothId() {
         return __classPrivateFieldGet(this, _Device_connectionManager, "f")?.bluetoothId;
     }
+    get isAvailable() {
+        return __classPrivateFieldGet(this, _Device_connectionManager, "f")?.isAvailable;
+    }
     constructor() {
         _Device_instances.add(this);
         _Device_eventDispatcher.set(this, new EventDispatcher(this, DeviceEventTypes));
         _Device_connectionManager.set(this, void 0);
         this.sendTxMessages = __classPrivateFieldGet(this, _Device_instances, "m", _Device_sendTxMessages).bind(this);
         _Device_isConnected.set(this, false);
-        _Device_reconnectOnDisconnection.set(this, _a$1.ReconnectOnDisconnection);
+        _Device_reconnectOnDisconnection.set(this, _a$2.ReconnectOnDisconnection);
         _Device_reconnectIntervalId.set(this, void 0);
-        this.latestConnectionMessage = new Map();
+        this.latestConnectionMessages = new Map();
         _Device_deviceInformationManager.set(this, new DeviceInformationManager());
         _Device_batteryLevel.set(this, 0);
         this._informationManager = new InformationManager();
         _Device_sensorConfigurationManager.set(this, new SensorConfigurationManager());
-        _Device_clearSensorConfigurationOnLeave.set(this, _a$1.ClearSensorConfigurationOnLeave);
+        _Device_clearSensorConfigurationOnLeave.set(this, _a$2.ClearSensorConfigurationOnLeave);
         _Device_sensorDataManager.set(this, new SensorDataManager());
         _Device_vibrationManager.set(this, new VibrationManager());
         _Device_fileTransferManager.set(this, new FileTransferManager());
@@ -4276,7 +4326,7 @@ class Device {
     }
     async connect() {
         if (!this.connectionManager) {
-            this.connectionManager = __classPrivateFieldGet(_a$1, _a$1, "m", _Device_DefaultConnectionManager).call(_a$1);
+            this.connectionManager = __classPrivateFieldGet(_a$2, _a$2, "m", _Device_DefaultConnectionManager).call(_a$2);
         }
         __classPrivateFieldGet(this, _Device_instances, "m", _Device_clear).call(this);
         return this.connectionManager.connect();
@@ -4293,16 +4343,16 @@ class Device {
         return this.connectionManager?.reconnect();
     }
     static async Connect() {
-        const device = new _a$1();
+        const device = new _a$2();
         await device.connect();
         return device;
     }
     static get ReconnectOnDisconnection() {
-        return __classPrivateFieldGet(this, _a$1, "f", _Device_ReconnectOnDisconnection);
+        return __classPrivateFieldGet(this, _a$2, "f", _Device_ReconnectOnDisconnection);
     }
     static set ReconnectOnDisconnection(newReconnectOnDisconnection) {
         _console$8.assertTypeWithError(newReconnectOnDisconnection, "boolean");
-        __classPrivateFieldSet(this, _a$1, newReconnectOnDisconnection, "f", _Device_ReconnectOnDisconnection);
+        __classPrivateFieldSet(this, _a$2, newReconnectOnDisconnection, "f", _Device_ReconnectOnDisconnection);
     }
     get reconnectOnDisconnection() {
         return __classPrivateFieldGet(this, _Device_reconnectOnDisconnection, "f");
@@ -4383,8 +4433,11 @@ class Device {
     get isInsole() {
         return this._informationManager.isInsole;
     }
-    get insoleSide() {
-        return this._informationManager.insoleSide;
+    get isGlove() {
+        return this._informationManager.isGlove;
+    }
+    get side() {
+        return this._informationManager.side;
     }
     get mtu() {
         return this._informationManager.mtu;
@@ -4405,11 +4458,11 @@ class Device {
         return __classPrivateFieldGet(this, _Device_sensorConfigurationManager, "f").clearSensorConfiguration();
     }
     static get ClearSensorConfigurationOnLeave() {
-        return __classPrivateFieldGet(this, _a$1, "f", _Device_ClearSensorConfigurationOnLeave);
+        return __classPrivateFieldGet(this, _a$2, "f", _Device_ClearSensorConfigurationOnLeave);
     }
     static set ClearSensorConfigurationOnLeave(newClearSensorConfigurationOnLeave) {
         _console$8.assertTypeWithError(newClearSensorConfigurationOnLeave, "boolean");
-        __classPrivateFieldSet(this, _a$1, newClearSensorConfigurationOnLeave, "f", _Device_ClearSensorConfigurationOnLeave);
+        __classPrivateFieldSet(this, _a$2, newClearSensorConfigurationOnLeave, "f", _Device_ClearSensorConfigurationOnLeave);
     }
     get clearSensorConfigurationOnLeave() {
         return __classPrivateFieldGet(this, _Device_clearSensorConfigurationOnLeave, "f");
@@ -4503,10 +4556,15 @@ class Device {
     get setTfliteThreshold() {
         return __classPrivateFieldGet(this, _Device_tfliteManager, "f").setThreshold;
     }
+    get canUpdateFirmware() {
+        return __classPrivateFieldGet(this, _Device_connectionManager, "f")?.canUpdateFirmware;
+    }
     get uploadFirmware() {
+        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertCanUpdateFirmware).call(this);
         return __classPrivateFieldGet(this, _Device_firmwareManager, "f").uploadFirmware;
     }
     async reset() {
+        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertCanUpdateFirmware).call(this);
         await __classPrivateFieldGet(this, _Device_firmwareManager, "f").reset();
         return __classPrivateFieldGet(this, _Device_connectionManager, "f").disconnect();
     }
@@ -4514,18 +4572,22 @@ class Device {
         return __classPrivateFieldGet(this, _Device_firmwareManager, "f").status;
     }
     get getFirmwareImages() {
+        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertCanUpdateFirmware).call(this);
         return __classPrivateFieldGet(this, _Device_firmwareManager, "f").getImages;
     }
     get firmwareImages() {
         return __classPrivateFieldGet(this, _Device_firmwareManager, "f").images;
     }
     get eraseFirmwareImage() {
+        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertCanUpdateFirmware).call(this);
         return __classPrivateFieldGet(this, _Device_firmwareManager, "f").eraseImage;
     }
     get confirmFirmwareImage() {
+        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertCanUpdateFirmware).call(this);
         return __classPrivateFieldGet(this, _Device_firmwareManager, "f").confirmImage;
     }
     get testFirmwareImage() {
+        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertCanUpdateFirmware).call(this);
         return __classPrivateFieldGet(this, _Device_firmwareManager, "f").testImage;
     }
     get isServerSide() {
@@ -4540,8 +4602,11 @@ class Device {
         __classPrivateFieldSet(this, _Device_isServerSide, newIsServerSide, "f");
         __classPrivateFieldGet(this, _Device_fileTransferManager, "f").isServerSide = this.isServerSide;
     }
+    get isUkaton() {
+        return this.deviceInformation.modelNumber.includes("Ukaton");
+    }
 }
-_a$1 = Device, _Device_eventDispatcher = new WeakMap(), _Device_connectionManager = new WeakMap(), _Device_isConnected = new WeakMap(), _Device_reconnectOnDisconnection = new WeakMap(), _Device_reconnectIntervalId = new WeakMap(), _Device_deviceInformationManager = new WeakMap(), _Device_batteryLevel = new WeakMap(), _Device_sensorConfigurationManager = new WeakMap(), _Device_clearSensorConfigurationOnLeave = new WeakMap(), _Device_sensorDataManager = new WeakMap(), _Device_vibrationManager = new WeakMap(), _Device_fileTransferManager = new WeakMap(), _Device_tfliteManager = new WeakMap(), _Device_firmwareManager = new WeakMap(), _Device_isServerSide = new WeakMap(), _Device_instances = new WeakSet(), _Device_DefaultConnectionManager = function _Device_DefaultConnectionManager() {
+_a$2 = Device, _Device_eventDispatcher = new WeakMap(), _Device_connectionManager = new WeakMap(), _Device_isConnected = new WeakMap(), _Device_reconnectOnDisconnection = new WeakMap(), _Device_reconnectIntervalId = new WeakMap(), _Device_deviceInformationManager = new WeakMap(), _Device_batteryLevel = new WeakMap(), _Device_sensorConfigurationManager = new WeakMap(), _Device_clearSensorConfigurationOnLeave = new WeakMap(), _Device_sensorDataManager = new WeakMap(), _Device_vibrationManager = new WeakMap(), _Device_fileTransferManager = new WeakMap(), _Device_tfliteManager = new WeakMap(), _Device_firmwareManager = new WeakMap(), _Device_isServerSide = new WeakMap(), _Device_instances = new WeakSet(), _Device_DefaultConnectionManager = function _Device_DefaultConnectionManager() {
     return new WebBluetoothConnectionManager();
 }, _Device_dispatchEvent_get = function _Device_dispatchEvent_get() {
     return __classPrivateFieldGet(this, _Device_eventDispatcher, "f").dispatchEvent;
@@ -4551,7 +4616,11 @@ _a$1 = Device, _Device_eventDispatcher = new WeakMap(), _Device_connectionManage
     _console$8.assertWithError(this.isConnected, "notConnected");
 }, _Device_hasRequiredInformation_get = function _Device_hasRequiredInformation_get() {
     return RequiredInformationConnectionMessages.every((messageType) => {
-        return this.latestConnectionMessage.has(messageType);
+        const hasConnectionMessage = this.latestConnectionMessages.has(messageType);
+        if (!hasConnectionMessage) {
+            _console$8.log(`didn't receive "${messageType}" message`);
+        }
+        return hasConnectionMessage;
     });
 }, _Device_requestRequiredInformation = function _Device_requestRequiredInformation() {
     const messages = RequiredInformationConnectionMessages.map((messageType) => ({
@@ -4563,6 +4632,7 @@ _a$1 = Device, _Device_eventDispatcher = new WeakMap(), _Device_connectionManage
 }, _Device_onConnectionStatusUpdated = function _Device_onConnectionStatusUpdated(connectionStatus) {
     _console$8.log({ connectionStatus });
     if (connectionStatus == "notConnected") {
+        __classPrivateFieldGet(this, _Device_instances, "m", _Device_clearConnection).call(this);
         if (this.canReconnect && this.reconnectOnDisconnection) {
             _console$8.log("starting reconnect interval...");
             __classPrivateFieldSet(this, _Device_reconnectIntervalId, setInterval(() => {
@@ -4607,10 +4677,12 @@ _a$1 = Device, _Device_eventDispatcher = new WeakMap(), _Device_connectionManage
             break;
     }
 }, _Device_clear = function _Device_clear() {
-    this.connectionManager?.clear();
-    this.latestConnectionMessage.clear();
+    __classPrivateFieldGet(this, _Device_instances, "m", _Device_clearConnection).call(this);
     this._informationManager.clear();
     __classPrivateFieldGet(this, _Device_deviceInformationManager, "f").clear();
+}, _Device_clearConnection = function _Device_clearConnection() {
+    this.connectionManager?.clear();
+    this.latestConnectionMessages.clear();
 }, _Device_onConnectionMessageReceived = function _Device_onConnectionMessageReceived(messageType, dataView) {
     _console$8.log({ messageType, dataView });
     switch (messageType) {
@@ -4645,7 +4717,7 @@ _a$1 = Device, _Device_eventDispatcher = new WeakMap(), _Device_connectionManage
                 throw Error(`uncaught messageType ${messageType}`);
             }
     }
-    this.latestConnectionMessage.set(messageType, dataView);
+    this.latestConnectionMessages.set(messageType, dataView);
     __classPrivateFieldGet(this, _Device_instances, "a", _Device_dispatchEvent_get).call(this, "connectionMessage", { messageType, dataView });
 }, _Device_onConnectionMessagesReceived = function _Device_onConnectionMessagesReceived() {
     if (!this.isConnected && __classPrivateFieldGet(this, _Device_instances, "a", _Device_hasRequiredInformation_get)) {
@@ -4664,28 +4736,34 @@ _a$1 = Device, _Device_eventDispatcher = new WeakMap(), _Device_connectionManage
     __classPrivateFieldSet(this, _Device_batteryLevel, updatedBatteryLevel, "f");
     _console$8.log({ updatedBatteryLevel: __classPrivateFieldGet(this, _Device_batteryLevel, "f") });
     __classPrivateFieldGet(this, _Device_instances, "a", _Device_dispatchEvent_get).call(this, "batteryLevel", { batteryLevel: __classPrivateFieldGet(this, _Device_batteryLevel, "f") });
+}, _Device_assertCanUpdateFirmware = function _Device_assertCanUpdateFirmware() {
+    _console$8.assertWithError(this.canUpdateFirmware, "can't update firmware");
 }, _Device_sendSmpMessage = function _Device_sendSmpMessage(data) {
+    __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertCanUpdateFirmware).call(this);
     return __classPrivateFieldGet(this, _Device_connectionManager, "f").sendSmpMessage(data);
 };
 _Device_ReconnectOnDisconnection = { value: false };
 _Device_ClearSensorConfigurationOnLeave = { value: true };
 
-var _DevicePairPressureSensorDataManager_instances, _DevicePairPressureSensorDataManager_rawPressure, _DevicePairPressureSensorDataManager_centerOfPressureHelper, _DevicePairPressureSensorDataManager_hasAllPressureData_get, _DevicePairPressureSensorDataManager_updatePressureData;
-const _console$7 = createConsole("DevicePairPressureSensorDataManager", { log: true });
+var _DevicePairPressureSensorDataManager_instances, _DevicePairPressureSensorDataManager_rawPressure, _DevicePairPressureSensorDataManager_centerOfPressureHelper, _DevicePairPressureSensorDataManager_normalizedSumRangeHelper, _DevicePairPressureSensorDataManager_hasAllPressureData_get, _DevicePairPressureSensorDataManager_updatePressureData;
+const _console$7 = createConsole("DevicePairPressureSensorDataManager", { log: false });
 class DevicePairPressureSensorDataManager {
     constructor() {
         _DevicePairPressureSensorDataManager_instances.add(this);
         _DevicePairPressureSensorDataManager_rawPressure.set(this, {});
         _DevicePairPressureSensorDataManager_centerOfPressureHelper.set(this, new CenterOfPressureHelper());
+        _DevicePairPressureSensorDataManager_normalizedSumRangeHelper.set(this, new RangeHelper());
+        this.resetPressureRange();
     }
     resetPressureRange() {
         __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_centerOfPressureHelper, "f").reset();
+        __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_normalizedSumRangeHelper, "f").reset();
     }
     onDevicePressureData(event) {
         const { pressure } = event.message;
-        const insoleSide = event.target.insoleSide;
-        _console$7.log({ pressure, insoleSide });
-        __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_rawPressure, "f")[insoleSide] = pressure;
+        const { side } = event.target;
+        _console$7.log({ pressure, side });
+        __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_rawPressure, "f")[side] = pressure;
         if (__classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_instances, "a", _DevicePairPressureSensorDataManager_hasAllPressureData_get)) {
             return __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_instances, "m", _DevicePairPressureSensorDataManager_updatePressureData).call(this);
         }
@@ -4694,36 +4772,43 @@ class DevicePairPressureSensorDataManager {
         }
     }
 }
-_DevicePairPressureSensorDataManager_rawPressure = new WeakMap(), _DevicePairPressureSensorDataManager_centerOfPressureHelper = new WeakMap(), _DevicePairPressureSensorDataManager_instances = new WeakSet(), _DevicePairPressureSensorDataManager_hasAllPressureData_get = function _DevicePairPressureSensorDataManager_hasAllPressureData_get() {
-    return InsoleSides.every((side) => side in __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_rawPressure, "f"));
+_DevicePairPressureSensorDataManager_rawPressure = new WeakMap(), _DevicePairPressureSensorDataManager_centerOfPressureHelper = new WeakMap(), _DevicePairPressureSensorDataManager_normalizedSumRangeHelper = new WeakMap(), _DevicePairPressureSensorDataManager_instances = new WeakSet(), _DevicePairPressureSensorDataManager_hasAllPressureData_get = function _DevicePairPressureSensorDataManager_hasAllPressureData_get() {
+    return Sides.every((side) => side in __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_rawPressure, "f"));
 }, _DevicePairPressureSensorDataManager_updatePressureData = function _DevicePairPressureSensorDataManager_updatePressureData() {
-    const pressure = { rawSum: 0, normalizedSum: 0 };
-    InsoleSides.forEach((side) => {
-        pressure.rawSum += __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_rawPressure, "f")[side].scaledSum;
-        pressure.normalizedSum += __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_rawPressure, "f")[side].normalizedSum;
+    const pressure = { scaledSum: 0, normalizedSum: 0, sensors: { left: [], right: [] } };
+    Sides.forEach((side) => {
+        const sidePressure = __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_rawPressure, "f")[side];
+        pressure.scaledSum += sidePressure.scaledSum;
     });
-    if (pressure.normalizedSum > 0.001) {
+    pressure.normalizedSum += __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_normalizedSumRangeHelper, "f").updateAndGetNormalization(pressure.scaledSum, false);
+    if (pressure.scaledSum > 0) {
         pressure.center = { x: 0, y: 0 };
-        InsoleSides.forEach((side) => {
+        Sides.forEach((side) => {
             const sidePressure = __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_rawPressure, "f")[side];
-            const normalizedPressureSumWeight = sidePressure.normalizedSum / pressure.normalizedSum;
-            if (normalizedPressureSumWeight > 0) {
-                if (sidePressure.normalizedCenter?.y != undefined) {
-                    pressure.center.y += sidePressure.normalizedCenter.y * normalizedPressureSumWeight;
-                }
-                if (side == "right") {
-                    pressure.center.x = normalizedPressureSumWeight;
-                }
+            {
+                sidePressure.sensors.forEach((sensor) => {
+                    const _sensor = { ...sensor };
+                    _sensor.weightedValue = sensor.scaledValue / pressure.scaledSum;
+                    let { x, y } = sensor.position;
+                    x /= 2;
+                    if (side == "right") {
+                        x += 0.5;
+                    }
+                    _sensor.position = { x, y };
+                    pressure.center.x += _sensor.position.x * _sensor.weightedValue;
+                    pressure.center.y += _sensor.position.y * _sensor.weightedValue;
+                    pressure.sensors[side].push(_sensor);
+                });
             }
         });
-        pressure.normalizedCenter = __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_centerOfPressureHelper, "f").updateAndGetNormalization(pressure.center);
+        pressure.normalizedCenter = __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_centerOfPressureHelper, "f").updateAndGetNormalization(pressure.center, false);
     }
     _console$7.log({ devicePairPressure: pressure });
     return pressure;
 };
 
 var _DevicePairSensorDataManager_timestamps;
-const _console$6 = createConsole("DevicePairSensorDataManager", { log: true });
+const _console$6 = createConsole("DevicePairSensorDataManager", { log: false });
 const DevicePairSensorTypes = ["pressure", "sensorData"];
 const DevicePairSensorDataEventTypes = DevicePairSensorTypes;
 class DevicePairSensorDataManager {
@@ -4743,7 +4828,7 @@ class DevicePairSensorDataManager {
         if (!__classPrivateFieldGet(this, _DevicePairSensorDataManager_timestamps, "f")[sensorType]) {
             __classPrivateFieldGet(this, _DevicePairSensorDataManager_timestamps, "f")[sensorType] = {};
         }
-        __classPrivateFieldGet(this, _DevicePairSensorDataManager_timestamps, "f")[sensorType][event.target.insoleSide] = timestamp;
+        __classPrivateFieldGet(this, _DevicePairSensorDataManager_timestamps, "f")[sensorType][event.target.side] = timestamp;
         let value;
         switch (sensorType) {
             case "pressure":
@@ -4765,8 +4850,8 @@ class DevicePairSensorDataManager {
 }
 _DevicePairSensorDataManager_timestamps = new WeakMap();
 
-var _DevicePair_instances, _a, _DevicePair_eventDispatcher, _DevicePair_dispatchEvent_get, _DevicePair_left, _DevicePair_right, _DevicePair_addDeviceEventListeners, _DevicePair_removeDeviceEventListeners, _DevicePair_removeInsole, _DevicePair_boundDeviceEventListeners, _DevicePair_redispatchDeviceEvent, _DevicePair_onDeviceIsConnected, _DevicePair_onDeviceType, _DevicePair_sensorDataManager, _DevicePair_onDeviceSensorData, _DevicePair_shared;
-const _console$5 = createConsole("DevicePair", { log: true });
+var _DevicePair_instances, _a$1, _DevicePair_type, _DevicePair_eventDispatcher, _DevicePair_dispatchEvent_get, _DevicePair_left, _DevicePair_right, _DevicePair_isDeviceCorrectType, _DevicePair_addDeviceEventListeners, _DevicePair_removeDeviceEventListeners, _DevicePair_removeDevice, _DevicePair_boundDeviceEventListeners, _DevicePair_redispatchDeviceEvent, _DevicePair_onDeviceIsConnected, _DevicePair_onDeviceType, _DevicePair_sensorDataManager, _DevicePair_onDeviceSensorData, _DevicePair_insoles, _DevicePair_gloves;
+const _console$5 = createConsole("DevicePair", { log: false });
 function getDevicePairDeviceEventType(deviceEventType) {
     return `device${capitalizeFirstCharacter(deviceEventType)}`;
 }
@@ -4777,9 +4862,11 @@ const DevicePairEventTypes = [
     ...DevicePairSensorDataEventTypes,
     ...DevicePairDeviceEventTypes,
 ];
+const DevicePairTypes = ["insoles", "gloves"];
 class DevicePair {
-    constructor() {
+    constructor(type) {
         _DevicePair_instances.add(this);
+        _DevicePair_type.set(this, void 0);
         _DevicePair_eventDispatcher.set(this, new EventDispatcher(this, DevicePairEventTypes));
         _DevicePair_left.set(this, void 0);
         _DevicePair_right.set(this, void 0);
@@ -4789,10 +4876,14 @@ class DevicePair {
             getType: __classPrivateFieldGet(this, _DevicePair_instances, "m", _DevicePair_onDeviceType).bind(this),
         });
         _DevicePair_sensorDataManager.set(this, new DevicePairSensorDataManager());
+        __classPrivateFieldSet(this, _DevicePair_type, type, "f");
         __classPrivateFieldGet(this, _DevicePair_sensorDataManager, "f").eventDispatcher = __classPrivateFieldGet(this, _DevicePair_eventDispatcher, "f");
     }
     get sides() {
-        return InsoleSides;
+        return Sides;
+    }
+    get type() {
+        return __classPrivateFieldGet(this, _DevicePair_type, "f");
     }
     get addEventListener() {
         return __classPrivateFieldGet(this, _DevicePair_eventDispatcher, "f").addEventListener;
@@ -4816,20 +4907,20 @@ class DevicePair {
         return __classPrivateFieldGet(this, _DevicePair_right, "f");
     }
     get isConnected() {
-        return InsoleSides.every((side) => this[side]?.isConnected);
+        return Sides.every((side) => this[side]?.isConnected);
     }
     get isPartiallyConnected() {
-        return InsoleSides.some((side) => this[side]?.isConnected);
+        return Sides.some((side) => this[side]?.isConnected);
     }
     get isHalfConnected() {
         return this.isPartiallyConnected && !this.isConnected;
     }
-    assignInsole(device) {
-        if (!device.isInsole) {
-            _console$5.warn("device is not an insole");
+    assignDevice(device) {
+        if (!__classPrivateFieldGet(this, _DevicePair_instances, "m", _DevicePair_isDeviceCorrectType).call(this, device)) {
+            _console$5.warn(`device is incorrect type ${device.type} for ${this.type} devicePair`);
             return;
         }
-        const side = device.insoleSide;
+        const side = device.side;
         const currentDevice = this[side];
         if (device == currentDevice) {
             _console$5.log("device already assigned");
@@ -4847,35 +4938,46 @@ class DevicePair {
                 __classPrivateFieldSet(this, _DevicePair_right, device, "f");
                 break;
         }
-        _console$5.log(`assigned ${side} insole`, device);
+        _console$5.log(`assigned ${side} device`, device);
         this.resetPressureRange();
         __classPrivateFieldGet(this, _DevicePair_instances, "a", _DevicePair_dispatchEvent_get).call(this, "isConnected", { isConnected: this.isConnected });
         __classPrivateFieldGet(this, _DevicePair_instances, "a", _DevicePair_dispatchEvent_get).call(this, "deviceIsConnected", { device, isConnected: device.isConnected, side });
         return currentDevice;
     }
     async setSensorConfiguration(sensorConfiguration) {
-        for (let i = 0; i < InsoleSides.length; i++) {
-            const side = InsoleSides[i];
+        for (let i = 0; i < Sides.length; i++) {
+            const side = Sides[i];
             if (this[side]?.isConnected) {
                 await this[side].setSensorConfiguration(sensorConfiguration);
             }
         }
     }
     resetPressureRange() {
+        Sides.forEach((side) => this[side]?.resetPressureRange());
         __classPrivateFieldGet(this, _DevicePair_sensorDataManager, "f").resetPressureRange();
     }
     async triggerVibration(vibrationConfigurations, sendImmediately) {
-        const promises = InsoleSides.map((side) => {
+        const promises = Sides.map((side) => {
             return this[side]?.triggerVibration(vibrationConfigurations, sendImmediately);
         }).filter(Boolean);
         return Promise.allSettled(promises);
     }
-    static get shared() {
-        return __classPrivateFieldGet(this, _a, "f", _DevicePair_shared);
+    static get insoles() {
+        return __classPrivateFieldGet(this, _a$1, "f", _DevicePair_insoles);
+    }
+    static get gloves() {
+        return __classPrivateFieldGet(this, _a$1, "f", _DevicePair_gloves);
     }
 }
-_a = DevicePair, _DevicePair_eventDispatcher = new WeakMap(), _DevicePair_left = new WeakMap(), _DevicePair_right = new WeakMap(), _DevicePair_boundDeviceEventListeners = new WeakMap(), _DevicePair_sensorDataManager = new WeakMap(), _DevicePair_instances = new WeakSet(), _DevicePair_dispatchEvent_get = function _DevicePair_dispatchEvent_get() {
+_a$1 = DevicePair, _DevicePair_type = new WeakMap(), _DevicePair_eventDispatcher = new WeakMap(), _DevicePair_left = new WeakMap(), _DevicePair_right = new WeakMap(), _DevicePair_boundDeviceEventListeners = new WeakMap(), _DevicePair_sensorDataManager = new WeakMap(), _DevicePair_instances = new WeakSet(), _DevicePair_dispatchEvent_get = function _DevicePair_dispatchEvent_get() {
     return __classPrivateFieldGet(this, _DevicePair_eventDispatcher, "f").dispatchEvent;
+}, _DevicePair_isDeviceCorrectType = function _DevicePair_isDeviceCorrectType(device) {
+    switch (this.type) {
+        case "insoles":
+            return device.isInsole;
+        case "gloves":
+            return device.isGlove;
+    }
 }, _DevicePair_addDeviceEventListeners = function _DevicePair_addDeviceEventListeners(device) {
     addEventListeners(device, __classPrivateFieldGet(this, _DevicePair_boundDeviceEventListeners, "f"));
     DeviceEventTypes.forEach((deviceEventType) => {
@@ -4886,12 +4988,12 @@ _a = DevicePair, _DevicePair_eventDispatcher = new WeakMap(), _DevicePair_left =
     DeviceEventTypes.forEach((deviceEventType) => {
         device.removeEventListener(deviceEventType, __classPrivateFieldGet(this, _DevicePair_instances, "m", _DevicePair_redispatchDeviceEvent).bind(this));
     });
-}, _DevicePair_removeInsole = function _DevicePair_removeInsole(device) {
-    const foundDevice = InsoleSides.some((side) => {
+}, _DevicePair_removeDevice = function _DevicePair_removeDevice(device) {
+    const foundDevice = Sides.some((side) => {
         if (this[side] != device) {
             return false;
         }
-        _console$5.log(`removing ${side} insole`, device);
+        _console$5.log(`removing ${side} device`, device);
         removeEventListeners(device, __classPrivateFieldGet(this, _DevicePair_boundDeviceEventListeners, "f"));
         delete this[side];
         return true;
@@ -4905,31 +5007,35 @@ _a = DevicePair, _DevicePair_eventDispatcher = new WeakMap(), _DevicePair_left =
     __classPrivateFieldGet(this, _DevicePair_instances, "a", _DevicePair_dispatchEvent_get).call(this, getDevicePairDeviceEventType(type), {
         ...message,
         device,
-        side: device.insoleSide,
+        side: device.side,
     });
 }, _DevicePair_onDeviceIsConnected = function _DevicePair_onDeviceIsConnected(deviceEvent) {
     __classPrivateFieldGet(this, _DevicePair_instances, "a", _DevicePair_dispatchEvent_get).call(this, "isConnected", { isConnected: this.isConnected });
 }, _DevicePair_onDeviceType = function _DevicePair_onDeviceType(deviceEvent) {
     const { target: device } = deviceEvent;
-    if (this[device.insoleSide] == device) {
+    if (this[device.side] == device) {
         return;
     }
-    const foundDevice = __classPrivateFieldGet(this, _DevicePair_instances, "m", _DevicePair_removeInsole).call(this, device);
+    const foundDevice = __classPrivateFieldGet(this, _DevicePair_instances, "m", _DevicePair_removeDevice).call(this, device);
     if (!foundDevice) {
         return;
     }
-    this.assignInsole(device);
+    this.assignDevice(device);
 }, _DevicePair_onDeviceSensorData = function _DevicePair_onDeviceSensorData(deviceEvent) {
     if (this.isConnected) {
         __classPrivateFieldGet(this, _DevicePair_sensorDataManager, "f").onDeviceSensorData(deviceEvent);
     }
 };
-_DevicePair_shared = { value: new _a() };
+_DevicePair_insoles = { value: new _a$1("insoles") };
+_DevicePair_gloves = { value: new _a$1("gloves") };
 (() => {
     DeviceManager$1.AddEventListener("deviceConnected", (event) => {
         const { device } = event.message;
         if (device.isInsole) {
-            __classPrivateFieldGet(_a, _a, "f", _DevicePair_shared).assignInsole(device);
+            __classPrivateFieldGet(_a$1, _a$1, "f", _DevicePair_insoles).assignDevice(device);
+        }
+        if (device.isGlove) {
+            __classPrivateFieldGet(_a$1, _a$1, "f", _DevicePair_gloves).assignDevice(device);
         }
     });
 })();
@@ -4988,7 +5094,7 @@ createServerMessage("stopScan");
 createServerMessage("discoveredDevices");
 
 var _ClientConnectionManager_instances, _ClientConnectionManager_bluetoothId, _ClientConnectionManager_isConnected, _ClientConnectionManager_requestDeviceInformation, _ClientConnectionManager_onClientMessageCallback;
-const _console$3 = createConsole("ClientConnectionManager", { log: true });
+const _console$3 = createConsole("ClientConnectionManager", { log: false });
 const ClientDeviceInformationMessageTypes = [...DeviceInformationMessageTypes, "batteryLevel"];
 class ClientConnectionManager extends BaseConnectionManager {
     constructor() {
@@ -5003,6 +5109,9 @@ class ClientConnectionManager extends BaseConnectionManager {
     static get type() {
         return "client";
     }
+    get canUpdateFirmware() {
+        return false;
+    }
     get bluetoothId() {
         return __classPrivateFieldGet(this, _ClientConnectionManager_bluetoothId, "f");
     }
@@ -5029,6 +5138,9 @@ class ClientConnectionManager extends BaseConnectionManager {
             __classPrivateFieldGet(this, _ClientConnectionManager_instances, "m", _ClientConnectionManager_requestDeviceInformation).call(this);
         }
     }
+    get isAvailable() {
+        return this.client.isConnected;
+    }
     async connect() {
         await super.connect();
         this.sendClientConnectMessage();
@@ -5082,8 +5194,8 @@ _ClientConnectionManager_bluetoothId = new WeakMap(), _ClientConnectionManager_i
     }
 };
 
-var _BaseClient_instances, _BaseClient_reset, _BaseClient_devices, _BaseClient_eventDispatcher, _BaseClient__connectionStatus, _BaseClient_parseMessageCallback, _BaseClient__isScanningAvailable, _BaseClient_isScanningAvailable_get, _BaseClient_isScanningAvailable_set, _BaseClient_assertIsScanningAvailable, _BaseClient__isScanning, _BaseClient_isScanning_get, _BaseClient_isScanning_set, _BaseClient_requestIsScanning, _BaseClient_assertIsScanning, _BaseClient_assertIsNotScanning, _BaseClient_discoveredDevices, _BaseClient_onExpiredDiscoveredDevice, _BaseClient_getOrCreateDevice;
-const _console$2 = createConsole("BaseClient", { log: true });
+var _BaseClient_instances, _a, _BaseClient_reset, _BaseClient_devices, _BaseClient_eventDispatcher, _BaseClient__connectionStatus, _BaseClient_RequiredMessageTypes, _BaseClient_requiredMessageTypes_get, _BaseClient_receivedMessageTypes, _BaseClient_checkIfFullyConnected, _BaseClient_parseMessageCallback, _BaseClient__isScanningAvailable, _BaseClient_isScanningAvailable_get, _BaseClient_isScanningAvailable_set, _BaseClient_assertIsScanningAvailable, _BaseClient__isScanning, _BaseClient_isScanning_get, _BaseClient_isScanning_set, _BaseClient_requestIsScanning, _BaseClient_assertIsScanning, _BaseClient_assertIsNotScanning, _BaseClient_discoveredDevices, _BaseClient_onExpiredDiscoveredDevice, _BaseClient_getOrCreateDevice;
+const _console$2 = createConsole("BaseClient", { log: false });
 const ClientConnectionStatuses = ["notConnected", "connecting", "connected", "disconnecting"];
 const ClientEventTypes = [
     ...ClientConnectionStatuses,
@@ -5101,6 +5213,7 @@ class BaseClient {
         _BaseClient_eventDispatcher.set(this, new EventDispatcher(this, ClientEventTypes));
         this._reconnectOnDisconnection = this.baseConstructor.ReconnectOnDisconnection;
         _BaseClient__connectionStatus.set(this, "notConnected");
+        _BaseClient_receivedMessageTypes.set(this, []);
         _BaseClient__isScanningAvailable.set(this, false);
         _BaseClient__isScanning.set(this, false);
         _BaseClient_discoveredDevices.set(this, {});
@@ -5156,9 +5269,7 @@ class BaseClient {
             case "connected":
             case "notConnected":
                 this.dispatchEvent("isConnected", { isConnected: this.isConnected });
-                if (this.isConnected) {
-                    this.sendServerMessage("isScanningAvailable", "discoveredDevices", "connectedDevices");
-                }
+                if (this.isConnected) ;
                 else {
                     __classPrivateFieldGet(this, _BaseClient_instances, "m", _BaseClient_reset).call(this);
                 }
@@ -5168,9 +5279,14 @@ class BaseClient {
     get connectionStatus() {
         return this._connectionStatus;
     }
+    _sendRequiredMessages() {
+        _console$2.log("sending required messages", __classPrivateFieldGet(this, _BaseClient_receivedMessageTypes, "f"));
+        this.sendServerMessage(...__classPrivateFieldGet(this, _BaseClient_instances, "a", _BaseClient_requiredMessageTypes_get));
+    }
     parseMessage(dataView) {
         _console$2.log("parseMessage", { dataView });
         parseMessage(dataView, ServerMessageTypes, __classPrivateFieldGet(this, _BaseClient_instances, "m", _BaseClient_parseMessageCallback).bind(this), null, true);
+        __classPrivateFieldGet(this, _BaseClient_instances, "m", _BaseClient_checkIfFullyConnected).call(this);
     }
     get isScanningAvailable() {
         return __classPrivateFieldGet(this, _BaseClient_instances, "a", _BaseClient_isScanningAvailable_get);
@@ -5225,6 +5341,7 @@ class BaseClient {
     createDevice(bluetoothId) {
         const device = new Device();
         const clientConnectionManager = new ClientConnectionManager();
+        clientConnectionManager.client = this;
         clientConnectionManager.bluetoothId = bluetoothId;
         clientConnectionManager.sendClientMessage = this.sendDeviceMessage.bind(this, bluetoothId);
         clientConnectionManager.sendClientConnectMessage = this.sendConnectToDeviceMessage.bind(this, bluetoothId);
@@ -5238,6 +5355,7 @@ class BaseClient {
             const device = __classPrivateFieldGet(this, _BaseClient_instances, "m", _BaseClient_getOrCreateDevice).call(this, bluetoothId);
             const connectionManager = device.connectionManager;
             connectionManager.isConnected = true;
+            DeviceManager$1._CheckDeviceAvailability(device);
         });
     }
     disconnectFromDevice(bluetoothId) {
@@ -5261,7 +5379,7 @@ class BaseClient {
         });
     }
 }
-_BaseClient_devices = new WeakMap(), _BaseClient_eventDispatcher = new WeakMap(), _BaseClient__connectionStatus = new WeakMap(), _BaseClient__isScanningAvailable = new WeakMap(), _BaseClient__isScanning = new WeakMap(), _BaseClient_discoveredDevices = new WeakMap(), _BaseClient_instances = new WeakSet(), _BaseClient_reset = function _BaseClient_reset() {
+_a = BaseClient, _BaseClient_devices = new WeakMap(), _BaseClient_eventDispatcher = new WeakMap(), _BaseClient__connectionStatus = new WeakMap(), _BaseClient_receivedMessageTypes = new WeakMap(), _BaseClient__isScanningAvailable = new WeakMap(), _BaseClient__isScanning = new WeakMap(), _BaseClient_discoveredDevices = new WeakMap(), _BaseClient_instances = new WeakSet(), _BaseClient_reset = function _BaseClient_reset() {
     __classPrivateFieldSet(this, _BaseClient_instances, false, "a", _BaseClient_isScanningAvailable_set);
     __classPrivateFieldSet(this, _BaseClient_instances, false, "a", _BaseClient_isScanning_set);
     for (const id in __classPrivateFieldGet(this, _BaseClient_devices, "f")) {
@@ -5269,6 +5387,26 @@ _BaseClient_devices = new WeakMap(), _BaseClient_eventDispatcher = new WeakMap()
         const connectionManager = device.connectionManager;
         connectionManager.isConnected = false;
     }
+    __classPrivateFieldGet(this, _BaseClient_receivedMessageTypes, "f").length = 0;
+}, _BaseClient_requiredMessageTypes_get = function _BaseClient_requiredMessageTypes_get() {
+    return __classPrivateFieldGet(_a, _a, "f", _BaseClient_RequiredMessageTypes);
+}, _BaseClient_checkIfFullyConnected = function _BaseClient_checkIfFullyConnected() {
+    if (this.connectionStatus != "connecting") {
+        return;
+    }
+    _console$2.log("checking if fully connected...");
+    if (!__classPrivateFieldGet(this, _BaseClient_receivedMessageTypes, "f").includes("isScanningAvailable")) {
+        _console$2.log("not fully connected - didn't receive isScanningAvailable");
+        return;
+    }
+    if (this.isScanningAvailable) {
+        if (!__classPrivateFieldGet(this, _BaseClient_receivedMessageTypes, "f").includes("isScanning")) {
+            _console$2.log("not fully connected - didn't receive isScanning");
+            return;
+        }
+    }
+    _console$2.log("fully connected");
+    this._connectionStatus = "connected";
 }, _BaseClient_parseMessageCallback = function _BaseClient_parseMessageCallback(messageType, dataView) {
     let byteOffset = 0;
     _console$2.log({ messageType }, dataView);
@@ -5329,6 +5467,9 @@ _BaseClient_devices = new WeakMap(), _BaseClient_eventDispatcher = new WeakMap()
             _console$2.error(`uncaught messageType "${messageType}"`);
             break;
     }
+    if (this.connectionStatus == "connecting") {
+        __classPrivateFieldGet(this, _BaseClient_receivedMessageTypes, "f").push(messageType);
+    }
 }, _BaseClient_isScanningAvailable_get = function _BaseClient_isScanningAvailable_get() {
     return __classPrivateFieldGet(this, _BaseClient__isScanningAvailable, "f");
 }, _BaseClient_isScanningAvailable_set = function _BaseClient_isScanningAvailable_set(newIsAvailable) {
@@ -5372,6 +5513,7 @@ _BaseClient_devices = new WeakMap(), _BaseClient_eventDispatcher = new WeakMap()
     return device;
 };
 BaseClient._reconnectOnDisconnection = true;
+_BaseClient_RequiredMessageTypes = { value: ["isScanningAvailable", "discoveredDevices", "connectedDevices"] };
 
 const _console$1 = createConsole("WebSocketUtils", { log: false });
 const webSocketPingTimeout = 30_000_000;
@@ -5385,7 +5527,7 @@ createWebSocketMessage("ping");
 createWebSocketMessage("pong");
 
 var _WebSocketClient_instances, _WebSocketClient_webSocket, _WebSocketClient_sendWebSocketMessage, _WebSocketClient_boundWebSocketEventListeners, _WebSocketClient_onWebSocketOpen, _WebSocketClient_onWebSocketMessage, _WebSocketClient_onWebSocketClose, _WebSocketClient_onWebSocketError, _WebSocketClient_parseWebSocketMessage, _WebSocketClient_onServerMessage, _WebSocketClient_pingTimer, _WebSocketClient_ping, _WebSocketClient_pong;
-const _console = createConsole("WebSocketClient", { log: true });
+const _console = createConsole("WebSocketClient", { log: false });
 class WebSocketClient extends BaseClient {
     constructor() {
         super(...arguments);
@@ -5470,7 +5612,7 @@ _WebSocketClient_webSocket = new WeakMap(), _WebSocketClient_boundWebSocketEvent
 }, _WebSocketClient_onWebSocketOpen = function _WebSocketClient_onWebSocketOpen(event) {
     _console.log("webSocket.open", event);
     __classPrivateFieldGet(this, _WebSocketClient_pingTimer, "f").start();
-    this._connectionStatus = "connected";
+    this._sendRequiredMessages();
 }, _WebSocketClient_onWebSocketMessage = async function _WebSocketClient_onWebSocketMessage(event) {
     _console.log("webSocket.message", event);
     __classPrivateFieldGet(this, _WebSocketClient_pingTimer, "f").restart();
@@ -5514,5 +5656,5 @@ _WebSocketClient_webSocket = new WeakMap(), _WebSocketClient_boundWebSocketEvent
     __classPrivateFieldGet(this, _WebSocketClient_instances, "m", _WebSocketClient_sendWebSocketMessage).call(this, "pong");
 };
 
-export { ContinuousSensorTypes, DefaultNumberOfPressureSensors, Device, DeviceManager$1 as DeviceManager, DevicePair, DeviceTypes, environment as Environment, FileTransferDirections, FileTypes, InsoleSides, MaxNameLength, MaxNumberOfVibrationWaveformEffectSegments, MaxNumberOfVibrationWaveformSegments, MaxSensorRate, MaxVibrationWaveformEffectSegmentDelay, MaxVibrationWaveformEffectSegmentLoopCount, MaxVibrationWaveformEffectSequenceLoopCount, MaxVibrationWaveformSegmentDuration, MinNameLength, RangeHelper, SensorRateStep, SensorTypes, TfliteSensorTypes, TfliteTasks, VibrationLocations, VibrationTypes, VibrationWaveformEffects, WebSocketClient, setAllConsoleLevelFlags, setConsoleLevelFlagsForType };
+export { ContinuousSensorTypes, DefaultNumberOfPressureSensors, Device, DeviceManager$1 as DeviceManager, DevicePair, DevicePairTypes, DeviceTypes, environment as Environment, FileTransferDirections, FileTypes, MaxNameLength, MaxNumberOfVibrationWaveformEffectSegments, MaxNumberOfVibrationWaveformSegments, MaxSensorRate, MaxVibrationWaveformEffectSegmentDelay, MaxVibrationWaveformEffectSegmentLoopCount, MaxVibrationWaveformEffectSequenceLoopCount, MaxVibrationWaveformSegmentDuration, MinNameLength, RangeHelper, SensorRateStep, SensorTypes, Sides, TfliteSensorTypes, TfliteTasks, VibrationLocations, VibrationTypes, VibrationWaveformEffects, WebSocketClient, setAllConsoleLevelFlags, setConsoleLevelFlagsForType };
 //# sourceMappingURL=brilliantsole.module.js.map