brilliantsole 0.0.25 → 0.0.27

package/build/brilliantsole.node.module.js

@@ -329,7 +329,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);
@@ -476,7 +476,7 @@ async function getFileBuffer(file) {
 }
 
 var _FileTransferManager_instances, _a$6, _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$x = createConsole("FileTransferManager", { log: true });
+const _console$x = createConsole("FileTransferManager", { log: false });
 const FileTransferMessageTypes = [
     "maxFileLength",
     "getFileType",
@@ -801,7 +801,7 @@ _a$6 = FileTransferManager, _FileTransferManager_maxLength = new WeakMap(), _Fil
 };
 _FileTransferManager_MaxLength = { value: 0 };
 
-const _console$w = createConsole("MathUtils", { log: true });
+const _console$w = createConsole("MathUtils", { log: false });
 function getInterpolation(value, min, max, span) {
     if (span == undefined) {
         span = max - min;
@@ -889,15 +889,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();
@@ -918,8 +918,8 @@ function arrayWithoutDuplicates(array) {
     return array.filter((value, index) => array.indexOf(value) == index);
 }
 
-var _PressureSensorDataManager_positions, _PressureSensorDataManager_sensorRangeHelpers, _PressureSensorDataManager_centerOfPressureHelper;
-const _console$v = createConsole("PressureDataManager", { log: true });
+var _PressureSensorDataManager_positions, _PressureSensorDataManager_sensorRangeHelpers, _PressureSensorDataManager_normalizedSumRangeHelper, _PressureSensorDataManager_centerOfPressureHelper;
+const _console$v = createConsole("PressureDataManager", { log: false });
 const PressureSensorTypes = ["pressure"];
 const ContinuousPressureSensorTypes = PressureSensorTypes;
 const DefaultNumberOfPressureSensors = 8;
@@ -927,6 +927,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() {
@@ -949,37 +950,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$v.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$u = createConsole("MotionSensorDataManager", { log: true });
+const _console$u = createConsole("MotionSensorDataManager", { log: false });
 const MotionSensorTypes = [
     "acceleration",
     "gravity",
@@ -1072,7 +1074,7 @@ class MotionSensorDataManager {
 var _BarometerSensorDataManager_instances, _BarometerSensorDataManager_calculcateAltitude;
 const BarometerSensorTypes = ["barometer"];
 const ContinuousBarometerSensorTypes = BarometerSensorTypes;
-const _console$t = createConsole("BarometerSensorDataManager", { log: true });
+const _console$t = createConsole("BarometerSensorDataManager", { log: false });
 class BarometerSensorDataManager {
     constructor() {
         _BarometerSensorDataManager_instances.add(this);
@@ -1096,7 +1098,7 @@ _BarometerSensorDataManager_instances = new WeakSet(), _BarometerSensorDataManag
     return h;
 };
 
-const _console$s = createConsole("ParseUtils", { log: true });
+const _console$s = 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));
@@ -1126,7 +1128,7 @@ function parseMessage(dataView, messageTypes, callback, context, parseMessageLen
 }
 
 var _SensorDataManager_scalars;
-const _console$r = createConsole("SensorDataManager", { log: true });
+const _console$r = createConsole("SensorDataManager", { log: false });
 const SensorTypes = [...PressureSensorTypes, ...MotionSensorTypes, ...BarometerSensorTypes];
 const ContinuousSensorTypes = [
     ...ContinuousPressureSensorTypes,
@@ -1269,7 +1271,7 @@ function autoBind(self, {include, exclude} = {}) {
 }
 
 var _SensorConfigurationManager_instances, _a$5, _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$q = createConsole("SensorConfigurationManager", { log: true });
+const _console$q = createConsole("SensorConfigurationManager", { log: false });
 const MaxSensorRate = 2 ** 16 - 1;
 const SensorRateStep = 5;
 const SensorConfigurationMessageTypes = ["getSensorConfiguration", "setSensorConfiguration"];
@@ -1310,7 +1312,7 @@ class SensorConfigurationManager {
     }
     get zeroSensorConfiguration() {
         const zeroSensorConfiguration = {};
-        SensorTypes.forEach((sensorType) => {
+        __classPrivateFieldGet(this, _SensorConfigurationManager_availableSensorTypes, "f").forEach((sensorType) => {
             zeroSensorConfiguration[sensorType] = 0;
         });
         return zeroSensorConfiguration;
@@ -1336,7 +1338,7 @@ _a$5 = SensorConfigurationManager, _SensorConfigurationManager_availableSensorTy
 }, _SensorConfigurationManager_assertAvailableSensorType = function _SensorConfigurationManager_assertAvailableSensorType(sensorType) {
     _console$q.assertWithError(__classPrivateFieldGet(this, _SensorConfigurationManager_availableSensorTypes, "f"), "must get initial sensorConfiguration");
     const isSensorTypeAvailable = __classPrivateFieldGet(this, _SensorConfigurationManager_availableSensorTypes, "f")?.includes(sensorType);
-    _console$q.assert(isSensorTypeAvailable, `unavailable sensor type "${sensorType}"`);
+    _console$q.log(isSensorTypeAvailable, `unavailable sensor type "${sensorType}"`);
     return isSensorTypeAvailable;
 }, _SensorConfigurationManager_updateConfiguration = function _SensorConfigurationManager_updateConfiguration(updatedConfiguration) {
     __classPrivateFieldSet(this, _SensorConfigurationManager_configuration, updatedConfiguration, "f");
@@ -1393,7 +1395,7 @@ _SensorConfigurationManager_ZeroSensorConfiguration = { value: {} };
 })();
 
 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$p = createConsole("TfliteManager", { log: true });
+const _console$p = createConsole("TfliteManager", { log: false });
 const TfliteMessageTypes = [
     "getTfliteName",
     "setTfliteName",
@@ -1728,7 +1730,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$o = createConsole("DeviceInformationManager", { log: true });
+const _console$o = createConsole("DeviceInformationManager", { log: false });
 const DeviceInformationMessageTypes = [
     "manufacturerName",
     "modelNumber",
@@ -1803,7 +1805,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$o.log({ partialDeviceInformation });
     const deviceInformationNames = Object.keys(partialDeviceInformation);
@@ -1821,9 +1823,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$n = createConsole("InformationManager", { log: true });
-const DeviceTypes = ["leftInsole", "rightInsole"];
-const InsoleSides = ["left", "right"];
+const _console$n = createConsole("InformationManager", { log: false });
+const DeviceTypes = ["leftInsole", "rightInsole", "leftGlove", "rightGlove", "glasses", "generic"];
+const Sides = ["left", "right"];
 const MinNameLength = 2;
 const MaxNameLength = 30;
 const InformationMessageTypes = [
@@ -1918,12 +1920,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() {
@@ -1964,7 +1979,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$n.log({ mtu });
                 __classPrivateFieldGet(this, _InformationManager_instances, "m", _InformationManager_updateMtu).call(this, mtu);
                 break;
@@ -2339,8 +2357,8 @@ _VibrationManager_instances = new WeakSet(), _VibrationManager_verifyLocation =
     return data;
 };
 
-var _BaseConnectionManager_instances, _a$4, _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$l = createConsole("BaseConnectionManager", { log: true });
+var _BaseConnectionManager_instances, _a$4, _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$l = createConsole("BaseConnectionManager", { log: false });
 const ConnectionStatuses = ["notConnected", "connecting", "connected", "disconnecting"];
 const ConnectionEventTypes = [...ConnectionStatuses, "connectionStatus", "isConnected"];
 const TxRxMessageTypes = [
@@ -2371,6 +2389,9 @@ class BaseConnectionManager {
     get isSupported() {
         return this.baseConstructor.isSupported;
     }
+    get canUpdateFirmware() {
+        return false;
+    }
     get type() {
         return this.baseConstructor.type;
     }
@@ -2379,6 +2400,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);
     }
@@ -2401,12 +2424,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);
@@ -2441,7 +2467,7 @@ class BaseConnectionManager {
             return;
         }
         if (__classPrivateFieldGet(this, _BaseConnectionManager_isSendingMessages, "f")) {
-            console.log("already sending messages - waiting until later");
+            _console$l.log("already sending messages - waiting until later");
             return;
         }
         __classPrivateFieldSet(this, _BaseConnectionManager_isSendingMessages, true, "f");
@@ -2456,25 +2482,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$l.log("every arrayBuffer is too big to send");
+                    break;
+                }
+                _console$l.log("remaining arrayBuffers.length", arrayBuffers.length);
                 let arrayBufferByteLength = 0;
                 let arrayBufferCount = 0;
                 arrayBuffers.some((arrayBuffer) => {
                     if (arrayBufferByteLength + arrayBuffer.byteLength > this.mtu - 3) {
+                        _console$l.log(`stopping appending arrayBuffers ( length ${arrayBuffer.byteLength} too much)`);
                         return true;
                     }
+                    _console$l.log(`allowing arrayBuffer with length ${arrayBuffer.byteLength}`);
                     arrayBufferCount++;
                     arrayBufferByteLength += arrayBuffer.byteLength;
                 });
                 const arrayBuffersToSend = arrayBuffers.splice(0, arrayBufferCount);
                 _console$l.log({ arrayBufferCount, arrayBuffersToSend });
                 const arrayBuffer = concatenateArrayBuffers(...arrayBuffersToSend);
-                _console$l.log("sending arrayBuffer", arrayBuffer);
+                _console$l.log("sending arrayBuffer (partitioned)", arrayBuffer);
                 await this.sendTxData(arrayBuffer);
             }
         }
         else {
             const arrayBuffer = concatenateArrayBuffers(...arrayBuffers);
-            _console$l.log("sending arrayBuffer", arrayBuffer);
+            _console$l.log("sending arrayBuffer (all)", arrayBuffer);
             await this.sendTxData(arrayBuffer);
         }
         __classPrivateFieldSet(this, _BaseConnectionManager_isSendingMessages, false, "f");
@@ -2491,7 +2524,7 @@ class BaseConnectionManager {
         __classPrivateFieldGet(this, _BaseConnectionManager_pendingMessages, "f").length = 0;
     }
 }
-_a$4 = 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$4 = 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$l.assertEnumWithError(messageType, TxRxMessageTypes);
 }, _BaseConnectionManager_assertIsSupported = function _BaseConnectionManager_assertIsSupported() {
     _console$l.assertWithError(this.isSupported, `${this.constructor.name} is not supported`);
@@ -2702,12 +2735,15 @@ function getCharacteristicProperties(characteristicName) {
 }
 const serviceDataUUID = "0000";
 
-const _console$i = createConsole("BluetoothConnectionManager", { log: true });
+const _console$i = 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);
@@ -2733,7 +2769,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$h = createConsole("WebBluetoothConnectionManager", { log: true });
+const _console$h = createConsole("WebBluetoothConnectionManager", { log: false });
 var bluetooth;
 if (isInNode) {
     bluetooth = webbluetooth.bluetooth;
@@ -2755,6 +2791,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);
     }
@@ -3315,7 +3354,7 @@ const CBOR = {
   decode,
 };
 
-const _console$g = createConsole("mcumgr", { log: true });
+const _console$g = createConsole("mcumgr", { log: false });
 const constants = {
   MGMT_OP_READ: 0,
   MGMT_OP_READ_RSP: 1,
@@ -3646,7 +3685,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$f = createConsole("FirmwareManager", { log: true });
+const _console$f = createConsole("FirmwareManager", { log: false });
 const FirmwareMessageTypes = ["smp"];
 const FirmwareEventTypes = [
     ...FirmwareMessageTypes,
@@ -3894,7 +3933,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$e = createConsole("DeviceManager", { log: true });
+const _console$e = createConsole("DeviceManager", { log: false });
 const DeviceManagerEventTypes = [
     "deviceConnected",
     "deviceDisconnected",
@@ -4036,6 +4075,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$e.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")) {
@@ -4137,6 +4183,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$e.log({ AvailableDevices: this.AvailableDevices });
     __classPrivateFieldGet(this, _DeviceManager_instances, "a", _DeviceManager_DispatchEvent_get).call(this, "availableDevices", { availableDevices: this.AvailableDevices });
@@ -4147,7 +4194,7 @@ _DeviceManager_boundDeviceEventListeners = new WeakMap(), _DeviceManager_Connect
 DeviceManager.shared = new DeviceManager();
 var DeviceManager$1 = DeviceManager.shared;
 
-var _Device_instances, _a$3, _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$3, _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$d = createConsole("Device", { log: true });
 const DeviceEventTypes = [
     "connectionMessage",
@@ -4191,6 +4238,9 @@ 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));
@@ -4199,7 +4249,7 @@ class Device {
         _Device_isConnected.set(this, false);
         _Device_reconnectOnDisconnection.set(this, _a$3.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();
@@ -4391,8 +4441,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;
@@ -4511,10 +4564,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();
     }
@@ -4522,18 +4580,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() {
@@ -4548,6 +4610,9 @@ 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$3 = 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();
@@ -4559,7 +4624,11 @@ _a$3 = Device, _Device_eventDispatcher = new WeakMap(), _Device_connectionManage
     _console$d.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$d.log(`didn't receive "${messageType}" message`);
+        }
+        return hasConnectionMessage;
     });
 }, _Device_requestRequiredInformation = function _Device_requestRequiredInformation() {
     const messages = RequiredInformationConnectionMessages.map((messageType) => ({
@@ -4571,6 +4640,7 @@ _a$3 = Device, _Device_eventDispatcher = new WeakMap(), _Device_connectionManage
 }, _Device_onConnectionStatusUpdated = function _Device_onConnectionStatusUpdated(connectionStatus) {
     _console$d.log({ connectionStatus });
     if (connectionStatus == "notConnected") {
+        __classPrivateFieldGet(this, _Device_instances, "m", _Device_clearConnection).call(this);
         if (this.canReconnect && this.reconnectOnDisconnection) {
             _console$d.log("starting reconnect interval...");
             __classPrivateFieldSet(this, _Device_reconnectIntervalId, setInterval(() => {
@@ -4615,10 +4685,12 @@ _a$3 = 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$d.log({ messageType, dataView });
     switch (messageType) {
@@ -4653,7 +4725,7 @@ _a$3 = 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)) {
@@ -4672,28 +4744,34 @@ _a$3 = Device, _Device_eventDispatcher = new WeakMap(), _Device_connectionManage
     __classPrivateFieldSet(this, _Device_batteryLevel, updatedBatteryLevel, "f");
     _console$d.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$d.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$c = createConsole("DevicePairPressureSensorDataManager", { log: true });
+var _DevicePairPressureSensorDataManager_instances, _DevicePairPressureSensorDataManager_rawPressure, _DevicePairPressureSensorDataManager_centerOfPressureHelper, _DevicePairPressureSensorDataManager_normalizedSumRangeHelper, _DevicePairPressureSensorDataManager_hasAllPressureData_get, _DevicePairPressureSensorDataManager_updatePressureData;
+const _console$c = 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$c.log({ pressure, insoleSide });
-        __classPrivateFieldGet(this, _DevicePairPressureSensorDataManager_rawPressure, "f")[insoleSide] = pressure;
+        const { side } = event.target;
+        _console$c.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);
         }
@@ -4702,36 +4780,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$c.log({ devicePairPressure: pressure });
     return pressure;
 };
 
 var _DevicePairSensorDataManager_timestamps;
-const _console$b = createConsole("DevicePairSensorDataManager", { log: true });
+const _console$b = createConsole("DevicePairSensorDataManager", { log: false });
 const DevicePairSensorTypes = ["pressure", "sensorData"];
 const DevicePairSensorDataEventTypes = DevicePairSensorTypes;
 class DevicePairSensorDataManager {
@@ -4751,7 +4836,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":
@@ -4773,8 +4858,8 @@ class DevicePairSensorDataManager {
 }
 _DevicePairSensorDataManager_timestamps = new WeakMap();
 
-var _DevicePair_instances, _a$2, _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$a = createConsole("DevicePair", { log: true });
+var _DevicePair_instances, _a$2, _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$a = createConsole("DevicePair", { log: false });
 function getDevicePairDeviceEventType(deviceEventType) {
     return `device${capitalizeFirstCharacter(deviceEventType)}`;
 }
@@ -4785,9 +4870,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);
@@ -4797,10 +4884,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;
@@ -4824,20 +4915,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$a.warn("device is not an insole");
+    assignDevice(device) {
+        if (!__classPrivateFieldGet(this, _DevicePair_instances, "m", _DevicePair_isDeviceCorrectType).call(this, device)) {
+            _console$a.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$a.log("device already assigned");
@@ -4855,35 +4946,46 @@ class DevicePair {
                 __classPrivateFieldSet(this, _DevicePair_right, device, "f");
                 break;
         }
-        _console$a.log(`assigned ${side} insole`, device);
+        _console$a.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$2, "f", _DevicePair_shared);
+    static get insoles() {
+        return __classPrivateFieldGet(this, _a$2, "f", _DevicePair_insoles);
+    }
+    static get gloves() {
+        return __classPrivateFieldGet(this, _a$2, "f", _DevicePair_gloves);
     }
 }
-_a$2 = 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$2 = 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) => {
@@ -4894,12 +4996,12 @@ _a$2 = 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$a.log(`removing ${side} insole`, device);
+        _console$a.log(`removing ${side} device`, device);
         removeEventListeners(device, __classPrivateFieldGet(this, _DevicePair_boundDeviceEventListeners, "f"));
         delete this[side];
         return true;
@@ -4913,31 +5015,35 @@ _a$2 = 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$2() };
+_DevicePair_insoles = { value: new _a$2("insoles") };
+_DevicePair_gloves = { value: new _a$2("gloves") };
 (() => {
     DeviceManager$1.AddEventListener("deviceConnected", (event) => {
         const { device } = event.message;
         if (device.isInsole) {
-            __classPrivateFieldGet(_a$2, _a$2, "f", _DevicePair_shared).assignInsole(device);
+            __classPrivateFieldGet(_a$2, _a$2, "f", _DevicePair_insoles).assignDevice(device);
+        }
+        if (device.isGlove) {
+            __classPrivateFieldGet(_a$2, _a$2, "f", _DevicePair_gloves).assignDevice(device);
         }
     });
 })();
@@ -5065,7 +5171,7 @@ _a$1 = BaseScanner, _BaseScanner_boundEventListeners = new WeakMap(), _BaseScann
 _BaseScanner_DiscoveredDeviceExpirationTimeout = { value: 5000 };
 
 var _NobleConnectionManager_instances, _NobleConnectionManager_noblePeripheral, _NobleConnectionManager_unboundNoblePeripheralListeners, _NobleConnectionManager_onNoblePeripheralConnect, _NobleConnectionManager_onNoblePeripheralDisconnect, _NobleConnectionManager_onNoblePeripheralState, _NobleConnectionManager_removeEventListeners, _NobleConnectionManager_onNoblePeripheralRssiUpdate, _NobleConnectionManager_onNoblePeripheralServicesDiscover, _NobleConnectionManager_services, _NobleConnectionManager_unboundNobleServiceListeners, _NobleConnectionManager_onNobleServiceCharacteristicsDiscover, _NobleConnectionManager_unboundNobleCharacteristicListeners, _NobleConnectionManager_characteristics, _NobleConnectionManager_hasAllCharacteristics_get, _NobleConnectionManager_onNobleCharacteristicData, _NobleConnectionManager_onNobleCharacteristicWrite, _NobleConnectionManager_onNobleCharacteristicNotify;
-const _console$8 = createConsole("NobleConnectionManager", { log: true });
+const _console$8 = createConsole("NobleConnectionManager", { log: false });
 class NobleConnectionManager extends BluetoothConnectionManager {
     constructor() {
         super(...arguments);
@@ -5091,6 +5197,9 @@ class NobleConnectionManager extends BluetoothConnectionManager {
     get bluetoothId() {
         return __classPrivateFieldGet(this, _NobleConnectionManager_noblePeripheral, "f").id;
     }
+    get canUpdateFirmware() {
+        return __classPrivateFieldGet(this, _NobleConnectionManager_characteristics, "f").has("smp");
+    }
     static get isSupported() {
         return isInNode;
     }
@@ -5259,6 +5368,9 @@ _NobleConnectionManager_noblePeripheral = new WeakMap(), _NobleConnectionManager
     await this.connectionManager.onNobleServiceCharacteristicsDiscover(this, characteristics);
 }, _NobleConnectionManager_hasAllCharacteristics_get = function _NobleConnectionManager_hasAllCharacteristics_get() {
     return allCharacteristicNames.every((characteristicName) => {
+        if (characteristicName == "smp") {
+            return true;
+        }
         return __classPrivateFieldGet(this, _NobleConnectionManager_characteristics, "f").has(characteristicName);
     });
 }, _NobleConnectionManager_onNobleCharacteristicData = function _NobleConnectionManager_onNobleCharacteristicData(data, isNotification) {
@@ -5270,7 +5382,7 @@ _NobleConnectionManager_noblePeripheral = new WeakMap(), _NobleConnectionManager
 };
 
 var _NobleScanner_instances, _NobleScanner__isScanning, _NobleScanner_isScanning_get, _NobleScanner_isScanning_set, _NobleScanner__nobleState, _NobleScanner_nobleState_get, _NobleScanner_nobleState_set, _NobleScanner_boundNobleListeners, _NobleScanner_onNobleScanStart, _NobleScanner_onNobleScanStop, _NobleScanner_onNobleStateChange, _NobleScanner_onNobleDiscover, _NobleScanner_boundBaseScannerListeners, _NobleScanner_onExpiredDiscoveredDevice, _NobleScanner_noblePeripherals, _NobleScanner_assertValidNoblePeripheralId, _NobleScanner_createDevice;
-const _console$7 = createConsole("NobleScanner", { log: true });
+const _console$7 = createConsole("NobleScanner", { log: false });
 let isSupported = false;
 isSupported = true;
 class NobleScanner extends BaseScanner {
@@ -5371,8 +5483,10 @@ _NobleScanner__isScanning = new WeakMap(), _NobleScanner__nobleState = new WeakM
     const { manufacturerData, serviceData } = noblePeripheral.advertisement;
     if (manufacturerData) {
         _console$7.log("manufacturerData", manufacturerData);
-        const deviceTypeEnum = manufacturerData.readUint8(manufacturerData.byteLength - 1);
-        deviceType = DeviceTypes[deviceTypeEnum];
+        if (manufacturerData.byteLength >= 3) {
+            const deviceTypeEnum = manufacturerData.readUint8(2);
+            deviceType = DeviceTypes[deviceTypeEnum];
+        }
     }
     if (serviceData) {
         _console$7.log("serviceData", serviceData);
@@ -5477,8 +5591,11 @@ createServerMessage("stopScan");
 createServerMessage("discoveredDevices");
 
 var _BaseServer_instances, _a, _BaseServer_ClearSensorConfigurationsWhenNoClients, _BaseServer_clearSensorConfigurationsWhenNoClients, _BaseServer_boundServerListeners, _BaseServer_onClientConnected, _BaseServer_onClientDisconnected, _BaseServer_boundScannerListeners, _BaseServer_onScannerIsAvailable, _BaseServer_isScanningAvailableMessage_get, _BaseServer_onScannerIsScanning, _BaseServer_isScanningMessage_get, _BaseServer_onScannerDiscoveredDevice, _BaseServer_createDiscoveredDeviceMessage, _BaseServer_onExpiredDiscoveredDevice, _BaseServer_createExpiredDiscoveredDeviceMessage, _BaseServer_discoveredDevicesMessage_get, _BaseServer_connectedDevicesMessage_get, _BaseServer_boundDeviceListeners, _BaseServer_createDeviceMessage, _BaseServer_onDeviceConnectionMessage, _BaseServer_boundDeviceManagerListeners, _BaseServer_onDeviceConnected, _BaseServer_onDeviceDisconnected, _BaseServer_onDeviceIsConnected, _BaseServer_createDeviceIsConnectedMessage, _BaseServer_createDeviceServerMessage, _BaseServer_onClientMessage, _BaseServer_parseClientDeviceMessageCallback;
-const _console$4 = createConsole("BaseServer", { log: true });
-const ServerEventTypes = ["clientConnected", "clientDisconnected"];
+const _console$4 = createConsole("BaseServer", { log: false });
+const ServerEventTypes = [
+    "clientConnected",
+    "clientDisconnected",
+];
 class BaseServer {
     get addEventListener() {
         return this.eventDispatcher.addEventListener;
@@ -5562,7 +5679,8 @@ _a = BaseServer, _BaseServer_clearSensorConfigurationsWhenNoClients = new WeakMa
 }, _BaseServer_onClientDisconnected = function _BaseServer_onClientDisconnected(event) {
     event.message.client;
     _console$4.log("onClientDisconnected");
-    if (this.numberOfClients == 0 && this.clearSensorConfigurationsWhenNoClients) {
+    if (this.numberOfClients == 0 &&
+        this.clearSensorConfigurationsWhenNoClients) {
         DeviceManager$1.ConnectedDevices.forEach((device) => {
             device.clearSensorConfiguration();
             device.setTfliteInferencingEnabled(false);
@@ -5571,23 +5689,35 @@ _a = BaseServer, _BaseServer_clearSensorConfigurationsWhenNoClients = new WeakMa
 }, _BaseServer_onScannerIsAvailable = function _BaseServer_onScannerIsAvailable(event) {
     this.broadcastMessage(__classPrivateFieldGet(this, _BaseServer_instances, "a", _BaseServer_isScanningAvailableMessage_get));
 }, _BaseServer_isScanningAvailableMessage_get = function _BaseServer_isScanningAvailableMessage_get() {
-    return createServerMessage({ type: "isScanningAvailable", data: scanner$1.isScanningAvailable });
+    return createServerMessage({
+        type: "isScanningAvailable",
+        data: scanner$1.isScanningAvailable,
+    });
 }, _BaseServer_onScannerIsScanning = function _BaseServer_onScannerIsScanning(event) {
     this.broadcastMessage(__classPrivateFieldGet(this, _BaseServer_instances, "a", _BaseServer_isScanningMessage_get));
 }, _BaseServer_isScanningMessage_get = function _BaseServer_isScanningMessage_get() {
-    return createServerMessage({ type: "isScanning", data: scanner$1.isScanning });
+    return createServerMessage({
+        type: "isScanning",
+        data: scanner$1.isScanning,
+    });
 }, _BaseServer_onScannerDiscoveredDevice = function _BaseServer_onScannerDiscoveredDevice(event) {
     const { discoveredDevice } = event.message;
     _console$4.log(discoveredDevice);
     this.broadcastMessage(__classPrivateFieldGet(this, _BaseServer_instances, "m", _BaseServer_createDiscoveredDeviceMessage).call(this, discoveredDevice));
 }, _BaseServer_createDiscoveredDeviceMessage = function _BaseServer_createDiscoveredDeviceMessage(discoveredDevice) {
-    return createServerMessage({ type: "discoveredDevice", data: discoveredDevice });
+    return createServerMessage({
+        type: "discoveredDevice",
+        data: discoveredDevice,
+    });
 }, _BaseServer_onExpiredDiscoveredDevice = function _BaseServer_onExpiredDiscoveredDevice(event) {
     const { discoveredDevice } = event.message;
     _console$4.log("expired", discoveredDevice);
     this.broadcastMessage(__classPrivateFieldGet(this, _BaseServer_instances, "m", _BaseServer_createExpiredDiscoveredDeviceMessage).call(this, discoveredDevice));
 }, _BaseServer_createExpiredDiscoveredDeviceMessage = function _BaseServer_createExpiredDiscoveredDeviceMessage(discoveredDevice) {
-    return createServerMessage({ type: "expiredDiscoveredDevice", data: discoveredDevice.bluetoothId });
+    return createServerMessage({
+        type: "expiredDiscoveredDevice",
+        data: discoveredDevice.bluetoothId,
+    });
 }, _BaseServer_discoveredDevicesMessage_get = function _BaseServer_discoveredDevicesMessage_get() {
     const serverMessages = scanner$1.discoveredDevicesArray
         .filter((discoveredDevice) => {
@@ -5601,12 +5731,14 @@ _a = BaseServer, _BaseServer_clearSensorConfigurationsWhenNoClients = new WeakMa
 }, _BaseServer_connectedDevicesMessage_get = function _BaseServer_connectedDevicesMessage_get() {
     return createServerMessage({
         type: "connectedDevices",
-        data: JSON.stringify({ connectedDevices: DeviceManager$1.ConnectedDevices.map((device) => device.bluetoothId) }),
+        data: JSON.stringify({
+            connectedDevices: DeviceManager$1.ConnectedDevices.map((device) => device.bluetoothId),
+        }),
     });
 }, _BaseServer_createDeviceMessage = function _BaseServer_createDeviceMessage(device, messageType, dataView) {
     return {
         type: messageType,
-        data: dataView || device.latestConnectionMessage.get(messageType),
+        data: dataView || device.latestConnectionMessages.get(messageType),
     };
 }, _BaseServer_onDeviceConnectionMessage = function _BaseServer_onDeviceConnectionMessage(deviceEvent) {
     const { target: device, message } = deviceEvent;
@@ -5630,7 +5762,10 @@ _a = BaseServer, _BaseServer_clearSensorConfigurationsWhenNoClients = new WeakMa
     _console$4.log("onDeviceIsConnected", device.bluetoothId);
     this.broadcastMessage(__classPrivateFieldGet(this, _BaseServer_instances, "m", _BaseServer_createDeviceIsConnectedMessage).call(this, device));
 }, _BaseServer_createDeviceIsConnectedMessage = function _BaseServer_createDeviceIsConnectedMessage(device) {
-    return __classPrivateFieldGet(this, _BaseServer_instances, "m", _BaseServer_createDeviceServerMessage).call(this, device, { type: "isConnected", data: device.isConnected });
+    return __classPrivateFieldGet(this, _BaseServer_instances, "m", _BaseServer_createDeviceServerMessage).call(this, device, {
+        type: "isConnected",
+        data: device.isConnected,
+    });
 }, _BaseServer_createDeviceServerMessage = function _BaseServer_createDeviceServerMessage(device, ...messages) {
     return createServerMessage({
         type: "deviceMessage",
@@ -5720,7 +5855,7 @@ const webSocketPingMessage = createWebSocketMessage("ping");
 const webSocketPongMessage = createWebSocketMessage("pong");
 
 var _WebSocketServer_instances, _WebSocketServer_server, _WebSocketServer_boundWebSocketServerListeners, _WebSocketServer_onWebSocketServerClose, _WebSocketServer_onWebSocketServerConnection, _WebSocketServer_onWebSocketServerError, _WebSocketServer_onWebSocketServerHeaders, _WebSocketServer_onWebSocketServerListening, _WebSocketServer_boundWebSocketClientListeners, _WebSocketServer_onWebSocketClientOpen, _WebSocketServer_onWebSocketClientMessage, _WebSocketServer_onWebSocketClientClose, _WebSocketServer_onWebSocketClientError, _WebSocketServer_parseWebSocketClientMessage, _WebSocketServer_onClientMessage, _WebSocketServer_pingClient;
-const _console$2 = createConsole("WebSocketServer", { log: true });
+const _console$2 = createConsole("WebSocketServer", { log: false });
 class WebSocketServer extends BaseServer {
     constructor() {
         super(...arguments);
@@ -5853,7 +5988,7 @@ createUDPServerMessage("ping");
 const udpPongMessage = createUDPServerMessage("pong");
 
 var _UDPServer_instances, _UDPServer_clients, _UDPServer_getClientByRemoteInfo, _UDPServer_remoteInfoToString, _UDPServer_clientToString, _UDPServer_socket, _UDPServer_boundSocketListeners, _UDPServer_onSocketClose, _UDPServer_onSocketConnect, _UDPServer_onSocketError, _UDPServer_onSocketListening, _UDPServer_onSocketMessage, _UDPServer_onClientData, _UDPServer_onClientUDPMessage, _UDPServer_createPongMessage, _UDPServer_parseRemoteReceivePort, _UDPServer_sendToClient, _UDPServer_removeClient;
-const _console = createConsole("UDPServer", { log: true });
+const _console = createConsole("UDPServer", { log: false });
 class UDPServer extends BaseServer {
     constructor() {
         super(...arguments);
@@ -6006,5 +6141,5 @@ _UDPServer_clients = new WeakMap(), _UDPServer_socket = new WeakMap(), _UDPServe
     this.dispatchEvent("clientDisconnected", { client });
 };
 
-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, scanner$1 as Scanner, SensorRateStep, SensorTypes, TfliteSensorTypes, TfliteTasks, UDPServer, VibrationLocations, VibrationTypes, VibrationWaveformEffects, WebSocketServer, 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, scanner$1 as Scanner, SensorRateStep, SensorTypes, Sides, TfliteSensorTypes, TfliteTasks, UDPServer, VibrationLocations, VibrationTypes, VibrationWaveformEffects, WebSocketServer, setAllConsoleLevelFlags, setConsoleLevelFlagsForType };
 //# sourceMappingURL=brilliantsole.node.module.js.map