@robotical/raftjs 2.1.0 → 2.1.2

package/dist/web/RaftDeviceManager.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceManager = void 0;
 const tslib_1 = require("tslib");
 const RaftDeviceStates_1 = require("./RaftDeviceStates");
+const RaftDeviceInfo_1 = require("./RaftDeviceInfo");
 const RaftAttributeHandler_1 = tslib_1.__importDefault(require("./RaftAttributeHandler"));
 const RaftStruct_1 = require("./RaftStruct");
 class DeviceManager {
@@ -20,6 +21,12 @@ class DeviceManager {
     getDeviceState(deviceKey) {
         return this._devicesState[deviceKey];
     }
+    getDeviceStats(deviceKey) {
+        return this.cloneDeviceStats(this.getOrCreateDeviceStats(deviceKey));
+    }
+    resetDeviceStats(deviceKey) {
+        this._deviceStats[deviceKey] = this.createEmptyStats();
+    }
     // Constructor
     constructor() {
         // Max data points to store
@@ -42,8 +49,13 @@ class DeviceManager {
         this._newDeviceAttributeCallbacks = [];
         this._newAttributeDataCallbacks = [];
         this._decodedDataCallbacks = [];
+        this._deviceRemovedCallbacks = [];
         // Debug message index (to help debug with async messages)
         this._debugMsgIndex = 0;
+        // Device stats (sample counts, rates)
+        this._statsWindowMs = 5000;
+        this._deviceStats = {};
+        this._malformedSampleWarnLastMs = {};
         // Cached device type data
         this._cachedDeviceTypeRecs = {};
         // Cached device type previous attempt times
@@ -120,6 +132,14 @@ class DeviceManager {
     removeDecodedDataCallback(callback) {
         this._decodedDataCallbacks = this._decodedDataCallbacks.filter((cb) => cb !== callback);
     }
+    addDeviceRemovedCallback(callback) {
+        if (!this._deviceRemovedCallbacks.includes(callback)) {
+            this._deviceRemovedCallbacks.push(callback);
+        }
+    }
+    removeDeviceRemovedCallback(callback) {
+        this._deviceRemovedCallbacks = this._deviceRemovedCallbacks.filter((cb) => cb !== callback);
+    }
     ////////////////////////////////////////////////////////////////////////////
     // Set the friendly name for the device
     ////////////////////////////////////////////////////////////////////////////
@@ -133,75 +153,183 @@ class DeviceManager {
     ////////////////////////////////////////////////////////////////////////////
     async handleClientMsgBinary(rxMsg) {
         // console.log(`DeviceManager client1 msg ${RaftUtils.bufferToHex(rxMsg)}`);
-        // Example messages
-        // 0080  0015 81 0000006a 0004 53b7 feff00000100081857079314  0011 80 00000000 0011 53b2 075106e400d60054  0010 80 00000000 0012 5231 000d0000010e01
-        // 0080  0011 80 00000000 0002 4ae1 0787052606240007  000e 80 00000000 0003 0006 030001af01
-        // 0080  0011 80 00000000 0002 e46e 061e05a206830433  0010 80000000000003e4760006030001c701
-        // 0080  0010 81 00000015 0004 e4a2 0650fe00305002    0011 80000000000002e4a8061f059f06850438   001080000000000003e4aa0006030001c701
-        // 0080  0011 80 00000000 0002 31e4 05ea05a506660137  000e 80 00000000 0003 0007 030001d901
-        // 0080  0011 80 00000000 0002 4d63 0792053e06500061  000e 80 00000000 0003 0005 030001de01
-        // First two bytes of each message are the message type (0080)
-        // There are then a series of sections each of which is the data for a device
-        //   First two bytes of each section is the section length (big endian) not including the section length bytes themselves
-        //   Next byte is the connection mode (0 for direct connect, 1+ for bus number) and the MSB of this byte is 1 if the device is online
-        //   Next is the device address (4 bytes big endian)
-        //   Next is the device type index (2 bytes big endian)
-        //   Finally the device data which can be one or more groups of attributes defined by the schema
+        var _a;
+        // DevBIN message format
+        //
+        // The rxMsg passed to this function has a 2-byte message type prefix (e.g. 0x0080)
+        // added by the transport layer. After that prefix comes a devbin frame:
+        //
+        // Current devbin envelope (3 bytes):
+        //   Byte 0: magic+version   0xDB (valid range 0xDB–0xDF)
+        //   Byte 1: topicIndex      0x00–0xFE = topic index; 0xFF = no topic
+        //   Byte 2: envelopeSeqNum  uint8, wrapping — detects whole-frame drops
+        //
+        // Then zero or more per-device records, concatenated back-to-back:
+        //   Bytes 0-1:  recordLen     uint16 big-endian — number of body bytes that follow (min 8)
+        //   Byte  2:    statusBus     bit 7 = online flag, bit 6 = pending deletion, bits 3:0 = bus number
+        //   Bytes 3-6:  address       uint32 big-endian — device address on the bus
+        //   Bytes 7-8:  devTypeIdx    uint16 big-endian — device type table index
+        //   Byte  9:    deviceSeqNum  uint8, wrapping — per-device drop detection
+        //   Bytes 10+:  samples       length-prefixed: [sampleLen(1B)][sampleData(sampleLen B)] × N
+        //
+        // Backwards compatibility:
+        //   Cog v1.9.5 is already in production and sends the older RaftCore devbin layout:
+        //   no 3-byte envelope, no deviceSeqNum byte, and raw fixed-size samples
+        //   [timestamp(2B)][payload] × N. Keep that path separate so current Axiom/Cog
+        //   frames continue to use the length-prefixed parser above.
+        //
+        // Example message (two device records; first record has two samples):
+        //   0080 DB 01 07 0018 81 0000076a 000b 2a 07feff0000010008 07185707931400 01 000e 80 00000000 001f 05 05030001af01
+        //   ^^^^                                                                       ^^^^
+        //   |    ^^ ^^ ^^                                                              Record 2 ...
+        //   |    |  |  envelopeSeqNum = 0x07                                           (same layout as Record 1)
+        //   |    |  topicIndex = 0x01
+        //   |    magic+version = 0xDB (devbin v1)
+        //   msgType prefix (transport layer)
+        //
+        //   Record 1 breakdown:
+        //     0018               recordLen = 24 body bytes follow
+        //     81                 statusBus: online=1, pendDel=0, bus=1
+        //     0000076a           address = 0x0000076A (slot 7, I2C addr 0x6A)
+        //     000b               devTypeIdx = 11
+        //     2a                 deviceSeqNum = 42
+        //     07 feff0000010008  sample 1: sampleLen=7, 7 bytes of attribute data
+        //     07 18570793140001  sample 2: sampleLen=7, 7 bytes of attribute data
+        //
+        //   Record 2 breakdown:
+        //     000e               recordLen = 14 body bytes follow
+        //     80                 statusBus: online=1, pendDel=0, bus=0
+        //     00000000           address = 0x00000000 (direct-connect)
+        //     001f               devTypeIdx = 31
+        //     05                 deviceSeqNum = 5
+        //     05 030001af01      sample 1: sampleLen=5, 5 bytes of attribute data
         // Debug
         // const debugMsgTime = Date.now();
         const debugMsgIndex = this._debugMsgIndex++;
-        // Message layout
-        const msgTypeLen = 2; // Length of the message type (first two bytes)
-        const sectionLengthLen = 2; // Length of the inclusive section length (first two bytes of each section)
-        const sectionConnectionModeLen = 1; // Length of the connection mode (next byte after section length)
-        const sectionDeviceAddrLen = 4; // Length of the device address (next 4 bytes after connection mode)
-        const sectionDeviceTypeIdxLen = 2; // Length of the device type index (next 2 bytes after device address)
-        const sectionHeaderLen = sectionConnectionModeLen + sectionDeviceAddrLen + sectionDeviceTypeIdxLen;
+        // Message layout constants
+        const msgTypeLen = 2; // Transport-layer message type prefix (first two bytes, e.g. 0x0080)
+        const devbinEnvelopeLen = 3; // Devbin envelope: magic+version (1B) + topicIndex (1B) + envelopeSeqNum (1B)
+        const legacyDevbinEnvelopeLen = 2; // Intermediate/legacy envelope: magic+version (1B) + topicIndex (1B)
+        const devbinMagicMin = 0xDB;
+        const devbinMagicMax = 0xDF;
+        const recordLenLen = 2; // Per-record length prefix (uint16 big-endian)
+        const busInfoLen = 1; // statusBus byte: bit 7 = online, bit 6 = pending deletion, bits 3:0 = bus number
+        const deviceAddrLen = 4; // Device address (uint32 big-endian)
+        const devTypeIdxLen = 2; // Device type index (uint16 big-endian)
+        const deviceSeqNumLen = 1; // Per-device sequence counter
+        const currentRecordHeaderLen = busInfoLen + deviceAddrLen + devTypeIdxLen + deviceSeqNumLen; // = 8, minimum record body
+        const legacyRecordHeaderLen = busInfoLen + deviceAddrLen + devTypeIdxLen; // = 7, Cog v1.9.5 record body header
         // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} rxMsg.length ${rxMsg.length} rxMsg ${RaftUtils.bufferToHex(rxMsg)}`);
         // Start after the message type
         let msgPos = msgTypeLen;
-        // Iterate through sections
+        let payloadFormat = "legacyRaw";
+        // Check for devbin envelope (magic+version + topicIndex)
+        if (rxMsg.length >= msgTypeLen + legacyDevbinEnvelopeLen) {
+            const envelopeMagicVer = rxMsg[msgTypeLen];
+            if ((envelopeMagicVer & 0xF0) === 0xD0) {
+                if ((envelopeMagicVer < devbinMagicMin) || (envelopeMagicVer > devbinMagicMax)) {
+                    console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} invalid devbin envelope magic/version ${envelopeMagicVer}`);
+                    return;
+                }
+                const topicIndex = rxMsg[msgTypeLen + 1];
+                if (topicIndex !== 0xFF) {
+                    const topicName = (_a = this._systemUtils) === null || _a === void 0 ? void 0 : _a.getPublishTopicName(topicIndex);
+                    if (topicName && topicName !== "devbin") {
+                        return;
+                    }
+                }
+                const currentMsgPos = msgTypeLen + devbinEnvelopeLen;
+                const legacyMsgPos = msgTypeLen + legacyDevbinEnvelopeLen;
+                if (this.hasValidRecordAt(rxMsg, currentMsgPos, recordLenLen, currentRecordHeaderLen)) {
+                    msgPos = currentMsgPos;
+                    payloadFormat = "lengthPrefixed";
+                }
+                else if (this.hasValidRecordAt(rxMsg, legacyMsgPos, recordLenLen, legacyRecordHeaderLen)) {
+                    msgPos = legacyMsgPos;
+                    payloadFormat = "legacyRaw";
+                }
+                else {
+                    console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} invalid devbin envelope payload`);
+                    return;
+                }
+            }
+        }
+        else if (this.hasValidRecordAt(rxMsg, msgPos, recordLenLen, currentRecordHeaderLen)) {
+            payloadFormat = "lengthPrefixed";
+        }
+        // Iterate through device records
         while (msgPos < rxMsg.length) {
-            // Check length
+            // Check minimum length for record length prefix + record header
             const remainingLen = rxMsg.length - msgPos;
-            if (remainingLen < sectionLengthLen + sectionHeaderLen) {
-                console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} invalid length ${rxMsg.length} < ${sectionLengthLen + sectionHeaderLen + msgPos}`);
+            if (remainingLen < recordLenLen + legacyRecordHeaderLen) {
+                console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} invalid length ${rxMsg.length} < ${recordLenLen + legacyRecordHeaderLen + msgPos}`);
+                return;
+            }
+            // Get the record body length (bytes that follow the 2-byte length prefix)
+            const recordLen = (rxMsg[msgPos] << 8) + rxMsg[msgPos + 1];
+            if ((recordLen < legacyRecordHeaderLen) || (recordLen > remainingLen - recordLenLen)) {
+                console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} invalid msgPos ${msgPos} recordLen ${recordLen} remainingAfterLenBytes ${remainingLen - recordLenLen}`);
                 return;
             }
-            // Get the length of the section
-            const sectionLen = (rxMsg[msgPos] << 8) + rxMsg[msgPos + 1];
-            if (sectionLen > remainingLen + sectionLengthLen) {
-                console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} invalid msgPos ${msgPos} msgLen ${sectionLen} remainingLenAfterLenBytes ${remainingLen - sectionLengthLen}`);
+            // Extract record header fields
+            let recordPos = msgPos + recordLenLen;
+            // statusBus byte: bit 7 = online, bit 6 = pending deletion, bits 3:0 = bus number
+            const statusByte = rxMsg[recordPos];
+            const busNum = statusByte & 0x0f;
+            const isOnline = (statusByte & 0x80) !== 0;
+            recordPos += busInfoLen;
+            // Device address (uint32 big-endian)
+            const devAddr = (rxMsg[recordPos] << 24) + (rxMsg[recordPos + 1] << 16) + (rxMsg[recordPos + 2] << 8) + rxMsg[recordPos + 3];
+            recordPos += deviceAddrLen;
+            // Device type index (uint16 big-endian)
+            const devTypeIdx = (rxMsg[recordPos] << 8) + rxMsg[recordPos + 1];
+            recordPos += devTypeIdxLen;
+            const commonRecordHeaderEndPos = recordPos;
+            const samplesEndPos = msgPos + recordLenLen + recordLen;
+            let recordPayloadFormat = payloadFormat;
+            let recordHeaderLen = recordPayloadFormat === "lengthPrefixed" ? currentRecordHeaderLen : legacyRecordHeaderLen;
+            const resolvedDeviceTypeInfo = await this.getDeviceTypeInfo(busNum.toString(), devTypeIdx.toString());
+            if (resolvedDeviceTypeInfo === null || resolvedDeviceTypeInfo === void 0 ? void 0 : resolvedDeviceTypeInfo.resp) {
+                recordPayloadFormat = this.resolveRecordPayloadFormat(rxMsg, commonRecordHeaderEndPos, samplesEndPos, resolvedDeviceTypeInfo.resp, recordPayloadFormat, deviceSeqNumLen);
+                recordHeaderLen = recordPayloadFormat === "lengthPrefixed" ? currentRecordHeaderLen : legacyRecordHeaderLen;
+            }
+            if (recordLen < recordHeaderLen) {
+                console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} invalid msgPos ${msgPos} recordLen ${recordLen} recordHeaderLen ${recordHeaderLen}`);
                 return;
             }
-            // Extract message elements
-            let sectionPos = msgPos + sectionLengthLen;
-            const busNum = rxMsg[sectionPos] & 0x7f;
-            const isOnline = (rxMsg[sectionPos] & 0x80) !== 0;
-            sectionPos += sectionConnectionModeLen;
-            // Get the device address and type index
-            const devAddr = (rxMsg[sectionPos] << 24) + (rxMsg[sectionPos + 1] << 16) + (rxMsg[sectionPos + 2] << 8) + rxMsg[sectionPos + 3];
-            sectionPos += sectionDeviceAddrLen;
-            const devTypeIdx = (rxMsg[sectionPos] << 8) + rxMsg[sectionPos + 1];
-            let attrGroupPos = sectionPos + sectionDeviceTypeIdxLen;
+            const isPendingDeletion = (recordPayloadFormat === "lengthPrefixed") && ((statusByte & 0x40) !== 0);
+            recordPos = commonRecordHeaderEndPos;
+            if (recordPayloadFormat === "lengthPrefixed") {
+                // Per-device sequence counter (reserved for future drop detection)
+                // const deviceSeqNum = rxMsg[recordPos];
+                recordPos += deviceSeqNumLen;
+            }
+            let pollDataPos = recordPos;
             // Debug
-            // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} overallLen ${rxMsg.length} sectionPos ${msgPos} sectionLen ${sectionLen} ${attrGroupPos} ${RaftUtils.bufferToHex(rxMsg.slice(msgPos, msgPos + sectionLen))}`);
-            // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} connMode ${busNum} isOnline ${isOnline} devAddr ${devAddr} devTypeIdx ${devTypeIdx} attrGroupDataLen ${sectionLen - sectionHeaderLen}`);
-            // Device key
-            const deviceKey = (0, RaftDeviceStates_1.getDeviceKey)(busNum.toString(), devAddr.toString(), devTypeIdx.toString());
+            // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} overallLen ${rxMsg.length} recordStart ${msgPos} recordLen ${recordLen} ${pollDataPos} ${RaftUtils.bufferToHex(rxMsg.slice(msgPos, msgPos + recordLenLen + recordLen))}`);
+            // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} bus ${busNum} isOnline ${isOnline} devAddr 0x${devAddr.toString(16)} devTypeIdx ${devTypeIdx} pollDataLen ${recordLen - recordHeaderLen}`);
+            // Format device address as canonical hex and build device key
+            const devAddrHex = (0, RaftDeviceStates_1.formatDeviceAddrHex)(devAddr);
+            const deviceKey = this.getBinaryDeviceKey(busNum, devAddrHex, devTypeIdx, recordPayloadFormat);
             // Update the last update time
             this._deviceLastUpdateTime[deviceKey] = Date.now();
+            // Handle pending deletion - remove device and skip further processing
+            if (isPendingDeletion) {
+                this.removeDevice(deviceKey);
+                msgPos += recordLenLen + recordLen;
+                continue;
+            }
             // Check if a device state already exists
             if (!(deviceKey in this._devicesState) || (this._devicesState[deviceKey].deviceTypeInfo === undefined)) {
                 // Get the device type info
-                const deviceTypeInfo = await this.getDeviceTypeInfo(busNum.toString(), devTypeIdx.toString());
+                const deviceTypeInfo = resolvedDeviceTypeInfo !== null && resolvedDeviceTypeInfo !== void 0 ? resolvedDeviceTypeInfo : await this.getDeviceTypeInfo(busNum.toString(), devTypeIdx.toString());
                 // Debug
-                // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} attrGroupPos ${attrGroupPos} busNum ${busNum} devAddr ${devAddr} devTypeIdx ${devTypeIdx} deviceTypeInfo ${JSON.stringify(deviceTypeInfo)}`);
+                // console.log(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} pollDataPos ${pollDataPos} busNum ${busNum} devAddr 0x${devAddr.toString(16)} devTypeIdx ${devTypeIdx} deviceTypeInfo ${JSON.stringify(deviceTypeInfo)}`);
                 // Handle case where device type info is not available
                 if (deviceTypeInfo === undefined) {
-                    console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} deviceType ${devTypeIdx} info not available, skipping attribute processing for this section`);
-                    // Skip to next section without processing attributes
-                    msgPos += sectionLengthLen + sectionLen;
+                    console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} deviceType ${devTypeIdx} info not available, skipping attribute processing for this record`);
+                    // Skip to next record without processing attributes
+                    msgPos += recordLenLen + recordLen;
                     continue;
                 }
                 // Check if device record exists
@@ -210,7 +338,7 @@ class DeviceManager {
                         this._devicesState[deviceKey].deviceTypeInfo = deviceTypeInfo;
                         this._devicesState[deviceKey].deviceType = deviceTypeInfo.name || "";
                         this._devicesState[deviceKey].busName = busNum.toString();
-                        this._devicesState[deviceKey].deviceAddress = devAddr.toString();
+                        this._devicesState[deviceKey].deviceAddress = devAddrHex;
                     }
                 }
                 else {
@@ -220,13 +348,19 @@ class DeviceManager {
                         deviceTimeline: {
                             timestampsUs: [],
                             lastReportTimestampUs: 0,
-                            reportTimestampOffsetUs: 0
+                            reportTimestampOffsetUs: 0,
+                            totalSamplesAdded: 0,
+                            emaLastSampleTimeUs: 0,
+                            emaIntervalUs: 0,
+                            emaPrevPollTimeUs: 0,
+                            emaCalibrated: false,
+                            emaCalibrationPolls: 0
                         },
                         deviceAttributes: {},
                         deviceIsNew: true,
                         stateChanged: false,
-                        isOnline: true,
-                        deviceAddress: devAddr.toString(),
+                        onlineState: RaftDeviceStates_1.DeviceOnlineState.Online,
+                        deviceAddress: devAddrHex,
                         deviceType: (deviceTypeInfo === null || deviceTypeInfo === void 0 ? void 0 : deviceTypeInfo.name) || "",
                         busName: busNum.toString()
                     };
@@ -234,48 +368,79 @@ class DeviceManager {
             }
             // Get device state
             const deviceState = this._devicesState[deviceKey];
-            deviceState.isOnline = isOnline;
+            deviceState.onlineState = isOnline ? RaftDeviceStates_1.DeviceOnlineState.Online : RaftDeviceStates_1.DeviceOnlineState.Offline;
             // Check if device type info is available and complete
             if (deviceState.deviceTypeInfo && deviceState.deviceTypeInfo.resp) {
                 // Iterate over attributes in the group
                 const pollRespMetadata = deviceState.deviceTypeInfo.resp;
-                // Iterate over attribute groups
-                const attrGroupDataLen = sectionLen - sectionHeaderLen;
-                const attrGroupStartPos = attrGroupPos;
+                // Process samples within this record
                 const attrLengthsBefore = this.snapshotAttrLengths(deviceState.deviceAttributes, pollRespMetadata);
                 const timelineLenBefore = deviceState.deviceTimeline.timestampsUs.length;
-                while (attrGroupPos < attrGroupStartPos + attrGroupDataLen) {
-                    // Add bounds checking
-                    if (attrGroupPos >= rxMsg.length) {
-                        console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} attrGroupPos ${attrGroupPos} exceeds message length ${rxMsg.length}`);
-                        break;
+                const totalSamplesBefore = deviceState.deviceTimeline.totalSamplesAdded;
+                if (recordPayloadFormat === "lengthPrefixed") {
+                    while (pollDataPos < samplesEndPos) {
+                        // Read sample length prefix
+                        if (pollDataPos >= rxMsg.length) {
+                            console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} pollDataPos ${pollDataPos} exceeds message length ${rxMsg.length}`);
+                            break;
+                        }
+                        const sampleLen = rxMsg[pollDataPos];
+                        pollDataPos += 1;
+                        if (sampleLen === 0 || pollDataPos + sampleLen > samplesEndPos) {
+                            break;
+                        }
+                        const sampleStartPos = pollDataPos;
+                        const sampleEndPos = pollDataPos + sampleLen;
+                        const newMsgBufIdx = this._attributeHandler.processMsgAttrGroup(rxMsg, sampleStartPos, deviceState.deviceTimeline, pollRespMetadata, deviceState.deviceAttributes, this._maxDatapointsToStore, sampleEndPos);
+                        if (newMsgBufIdx < 0) {
+                            this.warnMalformedSample(`${deviceKey}:${devTypeIdx}:lengthPrefixed`, `DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} skipped malformed sample ` +
+                                `device=${deviceKey} devTypeIdx=${devTypeIdx} sampleLen=${sampleLen} respBytes=${pollRespMetadata.b}`);
+                            pollDataPos += sampleLen;
+                            continue;
+                        }
+                        // Advance by sampleLen regardless of how much processMsgAttrGroup consumed
+                        pollDataPos += sampleLen;
+                        deviceState.stateChanged = true;
                     }
-                    const newMsgBufIdx = this._attributeHandler.processMsgAttrGroup(rxMsg, attrGroupPos, deviceState.deviceTimeline, pollRespMetadata, deviceState.deviceAttributes, this._maxDatapointsToStore);
-                    // console.log(`DevMan.handleClientMsgBinary decoded debugIdx ${debugMsgIndex} devType ${deviceState.deviceTypeInfo.name} attrGroupDataLen ${attrGroupDataLen} attrGroupPos ${attrGroupPos} sectionLen ${sectionLen} msgPos ${msgPos} rxMsgLen ${rxMsg.length} remainingLen ${remainingLen} pollRespMetadata ${JSON.stringify(pollRespMetadata)}`);
-                    if (newMsgBufIdx < 0) {
-                        console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} processMsgAttrGroup failed newMsgBufIdx ${newMsgBufIdx}`);
-                        break;
+                }
+                else {
+                    const legacySampleLen = this.getLegacyRawSampleLen(pollRespMetadata);
+                    if (legacySampleLen <= 0) {
+                        this.warnMalformedSample(`${deviceKey}:${devTypeIdx}:legacyRawLen`, `DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} invalid legacy sample length ` +
+                            `device=${deviceKey} devTypeIdx=${devTypeIdx} respBytes=${pollRespMetadata.b}`);
                     }
-                    // Prevent infinite loops
-                    if (newMsgBufIdx <= attrGroupPos) {
-                        console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} processMsgAttrGroup didn't advance position from ${attrGroupPos} to ${newMsgBufIdx}`);
-                        break;
+                    else {
+                        while (pollDataPos + legacySampleLen <= samplesEndPos) {
+                            const sampleStartPos = pollDataPos;
+                            const sampleEndPos = pollDataPos + legacySampleLen;
+                            const newMsgBufIdx = this._attributeHandler.processMsgAttrGroup(rxMsg, sampleStartPos, deviceState.deviceTimeline, pollRespMetadata, deviceState.deviceAttributes, this._maxDatapointsToStore, sampleEndPos);
+                            if (newMsgBufIdx < 0) {
+                                this.warnMalformedSample(`${deviceKey}:${devTypeIdx}:legacyRaw`, `DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} skipped malformed legacy sample ` +
+                                    `device=${deviceKey} devTypeIdx=${devTypeIdx} sampleLen=${legacySampleLen} respBytes=${pollRespMetadata.b}`);
+                                pollDataPos += legacySampleLen;
+                                continue;
+                            }
+                            pollDataPos += legacySampleLen;
+                            deviceState.stateChanged = true;
+                        }
+                        if (pollDataPos < samplesEndPos) {
+                            this.warnMalformedSample(`${deviceKey}:${devTypeIdx}:legacyRawRemainder`, `DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} skipped trailing legacy sample bytes ` +
+                                `device=${deviceKey} devTypeIdx=${devTypeIdx} remaining=${samplesEndPos - pollDataPos} sampleLen=${legacySampleLen} respBytes=${pollRespMetadata.b}`);
+                        }
                     }
-                    attrGroupPos = newMsgBufIdx;
-                    deviceState.stateChanged = true;
-                    // console.log(`debugMsgTime ${debugMsgTime} newPt debugMsgIdx ${debugMsgIndex} rxMsgLen ${rxMsg.length} devType ${deviceState.deviceTypeInfo!.name} timestampsUs ${deviceState.deviceTimeline.timestampsUs[deviceState.deviceTimeline.timestampsUs.length - 1]} curTimelineLen ${deviceState.deviceTimeline.timestampsUs.length}`);
-                    // console.log(`DevMan.handleClientMsgBinary group done debugIdx ${debugMsgIndex} attrGroupPos ${attrGroupPos} sectionLen ${sectionLen} msgPos ${msgPos} rxMsgLen ${rxMsg.length} remainingLen ${remainingLen}`);
                 }
                 // Inform decoded-data callbacks
-                this.emitDecodedData(deviceKey, busNum.toString(), devAddr.toString(), deviceState, pollRespMetadata, attrLengthsBefore, timelineLenBefore);
+                this.emitDecodedData(deviceKey, busNum.toString(), devAddrHex, deviceState, pollRespMetadata, attrLengthsBefore, timelineLenBefore);
+                const newSamples = deviceState.deviceTimeline.totalSamplesAdded - totalSamplesBefore;
+                this.updateDeviceStats(deviceKey, newSamples, Date.now());
             }
             else {
                 console.warn(`DevMan.handleClientMsgBinary debugIdx ${debugMsgIndex} deviceState incomplete for device ${deviceKey}, skipping attribute processing`);
             }
             // Debug
-            // console.log(`DevMan.handleClientMsgBinary section done debugIdx ${debugMsgIndex} attrGroupPos ${attrGroupPos} sectionLen ${sectionLen} msgPos ${msgPos} newMsgPos ${msgPos + sectionLengthLen + sectionLen} rxMsgLen ${rxMsg.length} remainingLen ${remainingLen}`);
-            // Move to next message
-            msgPos += sectionLengthLen + sectionLen;
+            // console.log(`DevMan.handleClientMsgBinary record done debugIdx ${debugMsgIndex} pollDataPos ${pollDataPos} recordLen ${recordLen} msgPos ${msgPos} newMsgPos ${msgPos + recordLenLen + recordLen} rxMsgLen ${rxMsg.length} remainingLen ${remainingLen}`);
+            // Advance past this record (recordLenLen + recordLen bytes)
+            msgPos += recordLenLen + recordLen;
         }
         // Check for devices that have not been updated for a while
         if (this._removeDevicesFlag) {
@@ -283,6 +448,7 @@ class DeviceManager {
             Object.entries(this._deviceLastUpdateTime).forEach(([deviceKey, lastUpdateTime]) => {
                 if ((nowTime - lastUpdateTime) > this._removeDevicesTimeMs) {
                     delete this._devicesState[deviceKey];
+                    delete this._deviceStats[deviceKey];
                 }
             });
         }
@@ -297,6 +463,10 @@ class DeviceManager {
         // console.log(`DeviceManager client msg ${JSON.stringify(data)}`);
         // Iterate over the buses
         Object.entries(data).forEach(([busName, devices]) => {
+            // Check the bus name doesn't start with _ which is reserved for non-device information such as topic name
+            if (busName.startsWith("_")) {
+                return;
+            }
             // Check for bus status info
             if (devices && typeof devices === "object" && "_s" in devices) {
                 // console.log(`DeviceManager bus status ${JSON.stringify(devices._s)}`);
@@ -304,21 +474,27 @@ class DeviceManager {
             }
             // Iterate over the devices
             Object.entries(devices).forEach(async ([devAddr, attrGroups]) => {
+                var _a;
                 // Check for non-device info (starts with _)
                 if (devAddr.startsWith("_")) {
                     return;
                 }
                 // Device type name
                 let deviceTypeName = "";
+                let deviceTypeIdx = -1;
                 if (attrGroups && typeof attrGroups === 'object' && "_t" in attrGroups && typeof attrGroups._t === "string") {
                     deviceTypeName = attrGroups._t || "";
                 }
+                else if (attrGroups && typeof attrGroups === 'object' && "_i" in attrGroups && typeof attrGroups._i === "number") {
+                    deviceTypeIdx = (_a = attrGroups._i) !== null && _a !== void 0 ? _a : -1;
+                    deviceTypeName = deviceTypeIdx.toString();
+                }
                 else {
                     console.warn(`DeviceManager missing device type attrGroups ${JSON.stringify(attrGroups)}`);
                     return;
                 }
                 // Device key
-                const deviceKey = (0, RaftDeviceStates_1.getDeviceKey)(busName, devAddr, deviceTypeName);
+                const deviceKey = (0, RaftDeviceStates_1.getDeviceKey)(busName, devAddr);
                 // Update the last update time
                 this._deviceLastUpdateTime[deviceKey] = Date.now();
                 // Check if a device state already exists
@@ -341,12 +517,18 @@ class DeviceManager {
                             deviceTimeline: {
                                 timestampsUs: [],
                                 lastReportTimestampUs: 0,
-                                reportTimestampOffsetUs: 0
+                                reportTimestampOffsetUs: 0,
+                                totalSamplesAdded: 0,
+                                emaLastSampleTimeUs: 0,
+                                emaIntervalUs: 0,
+                                emaPrevPollTimeUs: 0,
+                                emaCalibrated: false,
+                                emaCalibrationPolls: 0
                             },
                             deviceAttributes: {},
                             deviceIsNew: true,
                             stateChanged: false,
-                            isOnline: true,
+                            onlineState: RaftDeviceStates_1.DeviceOnlineState.Online,
                             deviceAddress: devAddr,
                             deviceType: deviceTypeName,
                             busName: busName
@@ -355,9 +537,15 @@ class DeviceManager {
                 }
                 // Get device state
                 const deviceState = this._devicesState[deviceKey];
-                // Check for online/offline state information
+                // Check for online/offline/pending-deletion state information
                 if (attrGroups && typeof attrGroups === "object" && "_o" in attrGroups) {
-                    deviceState.isOnline = ((attrGroups._o === true) || (attrGroups._o === "1") || (attrGroups._o === 1));
+                    const onlineStateVal = typeof attrGroups._o === 'number' ? attrGroups._o : parseInt(String(attrGroups._o), 10);
+                    if (onlineStateVal === 2) {
+                        // Pending deletion - remove device and skip further processing
+                        this.removeDevice(deviceKey);
+                        return;
+                    }
+                    deviceState.onlineState = onlineStateVal === 1 ? RaftDeviceStates_1.DeviceOnlineState.Online : RaftDeviceStates_1.DeviceOnlineState.Offline;
                 }
                 // Check if device type info is available
                 if (!deviceState.deviceTypeInfo) {
@@ -382,6 +570,7 @@ class DeviceManager {
                     const pollRespMetadata = deviceState.deviceTypeInfo.resp;
                     const attrLengthsBefore = this.snapshotAttrLengths(deviceState.deviceAttributes, pollRespMetadata);
                     const timelineLenBefore = deviceState.deviceTimeline.timestampsUs.length;
+                    const totalSamplesBefore = deviceState.deviceTimeline.totalSamplesAdded;
                     // Loop
                     while (msgBufIdx < msgBytes.length) {
                         const newMsgBufIdx = this._attributeHandler.processMsgAttrGroup(msgBytes, msgBufIdx, deviceState.deviceTimeline, pollRespMetadata, deviceState.deviceAttributes, this._maxDatapointsToStore);
@@ -391,6 +580,8 @@ class DeviceManager {
                         deviceState.stateChanged = true;
                     }
                     this.emitDecodedData(deviceKey, busName, devAddr, deviceState, pollRespMetadata, attrLengthsBefore, timelineLenBefore, attrGroupName, markers);
+                    const newSamples = deviceState.deviceTimeline.totalSamplesAdded - totalSamplesBefore;
+                    this.updateDeviceStats(deviceKey, newSamples, Date.now());
                 });
             });
         });
@@ -400,6 +591,7 @@ class DeviceManager {
             Object.entries(this._deviceLastUpdateTime).forEach(([deviceKey, lastUpdateTime]) => {
                 if ((nowTime - lastUpdateTime) > this._removeDevicesTimeMs) {
                     delete this._devicesState[deviceKey];
+                    delete this._deviceStats[deviceKey];
                 }
             });
         }
@@ -431,6 +623,20 @@ class DeviceManager {
         });
     }
     ////////////////////////////////////////////////////////////////////////////
+    // Remove a device (e.g. on pending deletion)
+    ////////////////////////////////////////////////////////////////////////////
+    removeDevice(deviceKey) {
+        // Snapshot the state before removal for callbacks
+        const deviceState = this._devicesState[deviceKey];
+        if (deviceState) {
+            deviceState.onlineState = RaftDeviceStates_1.DeviceOnlineState.PendingDeletion;
+            this._deviceRemovedCallbacks.forEach((cb) => cb(deviceKey, deviceState));
+        }
+        delete this._devicesState[deviceKey];
+        delete this._deviceLastUpdateTime[deviceKey];
+        delete this._deviceStats[deviceKey];
+    }
+    ////////////////////////////////////////////////////////////////////////////
     // Get device type info
     ////////////////////////////////////////////////////////////////////////////
     async getDeviceTypeInfo(busName, deviceType) {
@@ -499,6 +705,117 @@ class DeviceManager {
             return undefined;
         }
     }
+    hasValidRecordAt(rxMsg, msgPos, recordLenLen, recordHeaderLen) {
+        if (msgPos === rxMsg.length) {
+            return true;
+        }
+        if (msgPos < 0 || msgPos > rxMsg.length) {
+            return false;
+        }
+        const remainingLen = rxMsg.length - msgPos;
+        if (remainingLen < recordLenLen + recordHeaderLen) {
+            return false;
+        }
+        const recordLen = (rxMsg[msgPos] << 8) + rxMsg[msgPos + 1];
+        return (recordLen >= recordHeaderLen) && (recordLen <= remainingLen - recordLenLen);
+    }
+    resolveRecordPayloadFormat(rxMsg, commonRecordHeaderEndPos, samplesEndPos, pollRespMetadata, preferredFormat, deviceSeqNumLen) {
+        const lengthPrefixedStartPos = commonRecordHeaderEndPos + deviceSeqNumLen;
+        const lengthPrefixedValid = this.areLengthPrefixedSamplesValid(rxMsg, lengthPrefixedStartPos, samplesEndPos, pollRespMetadata);
+        const legacySampleLen = this.getLegacyRawSampleLen(pollRespMetadata);
+        const legacyRawValid = this.areLegacyRawSamplesValid(commonRecordHeaderEndPos, samplesEndPos, legacySampleLen);
+        if (legacyRawValid && !lengthPrefixedValid) {
+            return "legacyRaw";
+        }
+        if (lengthPrefixedValid && !legacyRawValid) {
+            return "lengthPrefixed";
+        }
+        if (lengthPrefixedValid && legacyRawValid) {
+            return preferredFormat;
+        }
+        return preferredFormat;
+    }
+    areLengthPrefixedSamplesValid(rxMsg, pollDataPos, samplesEndPos, pollRespMetadata) {
+        if ((pollDataPos < 0) || (pollDataPos > samplesEndPos) || (samplesEndPos > rxMsg.length)) {
+            return false;
+        }
+        if (pollDataPos === samplesEndPos) {
+            return true;
+        }
+        const fixedSampleLen = pollRespMetadata.c ? 0 : this.getLegacyRawSampleLen(pollRespMetadata);
+        let sampleCount = 0;
+        while (pollDataPos < samplesEndPos) {
+            const sampleLen = rxMsg[pollDataPos];
+            pollDataPos += 1;
+            if ((sampleLen === 0) || (pollDataPos + sampleLen > samplesEndPos)) {
+                return false;
+            }
+            if ((fixedSampleLen > 0) && (sampleLen !== fixedSampleLen)) {
+                return false;
+            }
+            pollDataPos += sampleLen;
+            sampleCount++;
+        }
+        return sampleCount > 0;
+    }
+    areLegacyRawSamplesValid(pollDataPos, samplesEndPos, legacySampleLen) {
+        if ((legacySampleLen <= 0) || (pollDataPos < 0) || (pollDataPos > samplesEndPos)) {
+            return false;
+        }
+        const payloadLen = samplesEndPos - pollDataPos;
+        return (payloadLen > 0) && (payloadLen % legacySampleLen === 0);
+    }
+    getBinaryDeviceKey(busNum, devAddrHex, devTypeIdx, payloadFormat) {
+        const baseDeviceKey = (0, RaftDeviceStates_1.getDeviceKey)(busNum.toString(), devAddrHex);
+        if ((payloadFormat === "legacyRaw") && (busNum === 0) && (devAddrHex === "0")) {
+            return `${baseDeviceKey}_${devTypeIdx}`;
+        }
+        return baseDeviceKey;
+    }
+    getLegacyRawSampleLen(pollRespMetadata) {
+        const legacyTimestampLen = 2;
+        return legacyTimestampLen + this.getPollRespPayloadSize(pollRespMetadata);
+    }
+    getPollRespPayloadSize(pollRespMetadata) {
+        if (pollRespMetadata.c) {
+            return pollRespMetadata.b;
+        }
+        let attrPayloadLen = 0;
+        for (const attrDef of pollRespMetadata.a) {
+            if (!attrDef.t) {
+                return pollRespMetadata.b;
+            }
+            try {
+                attrPayloadLen += (0, RaftStruct_1.structSizeOf)(attrDef.t);
+            }
+            catch (_a) {
+                return pollRespMetadata.b;
+            }
+        }
+        // Cog v1.9.5 light metadata reports the direct-sensor payload size doubled,
+        // but the legacy raw record contains one fixed payload matching the attribute schema.
+        if ((attrPayloadLen > 0) && (pollRespMetadata.b > 0) && (attrPayloadLen <= pollRespMetadata.b)) {
+            return attrPayloadLen;
+        }
+        return pollRespMetadata.b;
+    }
+    parseDeviceKeyForCommand(deviceKey) {
+        const deviceState = this._devicesState[deviceKey];
+        if (deviceState) {
+            return { bus: deviceState.busName, addr: deviceState.deviceAddress };
+        }
+        return (0, RaftDeviceStates_1.parseDeviceKey)(deviceKey);
+    }
+    warnMalformedSample(warningKey, message) {
+        var _a;
+        const nowMs = Date.now();
+        const lastWarnMs = (_a = this._malformedSampleWarnLastMs[warningKey]) !== null && _a !== void 0 ? _a : 0;
+        if (nowMs - lastWarnMs < 5000) {
+            return;
+        }
+        this._malformedSampleWarnLastMs[warningKey] = nowMs;
+        console.warn(message);
+    }
     ////////////////////////////////////////////////////////////////////////////
     // Send action to device
     ////////////////////////////////////////////////////////////////////////////
@@ -508,40 +825,77 @@ class DeviceManager {
             .join("");
     }
     async sendAction(deviceKey, action, data) {
-        // console.log(`DeviceManager sendAction ${deviceKey} action name ${action.n} value ${value} prefix ${action.w}`);
-        var _a;
-        let writeBytes;
-        // Check for one data item
-        if (data.length === 1) {
-            let value = data[0];
-            // Check for conversion
-            if (action.sub !== undefined) {
-                value = value - action.sub;
+        var _a, _b;
+        console.log(`DeviceManager sendAction ${deviceKey} action ${action.n} data ${data} map ${JSON.stringify(action.map)} keys ${action.map ? Object.keys(action.map) : 'none'}`);
+        // For _conf.* actions, delegate to setSampleRate() which coordinates polling params
+        if (action.n.startsWith('_conf.') && action.map && data.length === 1) {
+            const result = await this.setSampleRate(deviceKey, data[0]);
+            return result.ok;
+        }
+        let writeHexStr;
+        // Check if action has a map - use mapped hex value directly
+        if (action.map && data.length === 1) {
+            const mapKey = String(data[0]);
+            const mapEntry = action.map[mapKey];
+            if (!mapEntry) {
+                console.warn(`DeviceManager sendAction: no map entry for value ${mapKey} in action ${action.n}`);
+                return false;
+            }
+            const mappedHex = (0, RaftDeviceInfo_1.getActionMapHex)(mapEntry);
+            // Map values may contain &-separated multi-writes (e.g. "1048&114C&0a26")
+            const writes = mappedHex.split('&');
+            const { bus: devBus, addr: devAddr } = this.parseDeviceKeyForCommand(deviceKey);
+            try {
+                const msgHandler = (_a = this._systemUtils) === null || _a === void 0 ? void 0 : _a.getMsgHandler();
+                if (!msgHandler)
+                    return false;
+                for (const hexWr of writes) {
+                    const cmd = "devman/cmdraw?bus=" + devBus + "&addr=" + devAddr + "&hexWr=" + hexWr;
+                    console.log(`DeviceManager sendAction ${action.n} ${cmd}`);
+                    const msgRslt = await msgHandler.sendRICRESTURL(cmd);
+                    if (msgRslt.rslt !== "ok")
+                        return false;
+                }
+                return true;
             }
-            if (action.mul !== undefined) {
-                value = value * action.mul;
+            catch (error) {
+                console.warn(`DeviceManager sendAction error ${error}`);
+                return false;
             }
-            // Form the write bytes
-            writeBytes = action.t ? (0, RaftStruct_1.structPack)(action.t, [value]) : new Uint8Array(0);
         }
         else {
-            // Form the write bytes which may have multiple data items
-            writeBytes = action.t ? (0, RaftStruct_1.structPack)(action.t, data) : new Uint8Array(0);
+            let writeBytes;
+            // Check for one data item
+            if (data.length === 1) {
+                let value = data[0];
+                // Check for conversion
+                if (action.sub !== undefined) {
+                    value = value - action.sub;
+                }
+                if (action.mul !== undefined) {
+                    value = value * action.mul;
+                }
+                // Form the write bytes
+                writeBytes = action.t ? (0, RaftStruct_1.structPack)(action.t, [value]) : new Uint8Array(0);
+            }
+            else {
+                // Form the write bytes which may have multiple data items
+                writeBytes = action.t ? (0, RaftStruct_1.structPack)(action.t, data) : new Uint8Array(0);
+            }
+            // Convert to hex string
+            writeHexStr = this.toHex(writeBytes);
         }
-        // Convert to hex string
-        let writeHexStr = this.toHex(writeBytes);
         // Add prefix and postfix
         writeHexStr = (action.w ? action.w : "") + writeHexStr + (action.wz ? action.wz : "");
-        // Separate the bus and address in the deviceKey (_ char)
-        const devBus = deviceKey.split("_")[0];
-        const devAddr = deviceKey.split("_")[1];
+        // Parse the device key into bus and address components
+        const { bus: devBus, addr: devAddr } = this.parseDeviceKeyForCommand(deviceKey);
         // Send the action to the server
         const cmd = "devman/cmdraw?bus=" + devBus + "&addr=" + devAddr + "&hexWr=" + writeHexStr;
         console.log(`DeviceManager deviceKey ${deviceKey} action name ${action.n} value ${data} prefix ${action.w} sendAction ${cmd}`);
         // Send the command
         try {
             // Get the msg handler
-            const msgHandler = (_a = this._systemUtils) === null || _a === void 0 ? void 0 : _a.getMsgHandler();
+            const msgHandler = (_b = this._systemUtils) === null || _b === void 0 ? void 0 : _b.getMsgHandler();
             if (msgHandler) {
                 const msgRslt = await msgHandler.sendRICRESTURL(cmd);
                 return msgRslt.rslt === "ok";
@@ -581,6 +935,111 @@ class DeviceManager {
         return false;
     }
     ////////////////////////////////////////////////////////////////////////////
+    // Set sample rate with coordinated polling parameters
+    // Finds the closest supported rate from the device's _conf.rate action,
+    // calculates optimal intervalUs and numSamples, and sends a single
+    // /devman/devconfig call to set all parameters atomically.
+    ////////////////////////////////////////////////////////////////////////////
+    async setSampleRate(deviceKey, sampleRateHz, options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        // Look up device state and type info
+        const deviceState = this._devicesState[deviceKey];
+        if (!(deviceState === null || deviceState === void 0 ? void 0 : deviceState.deviceTypeInfo)) {
+            return { ok: false, requestedRateHz: sampleRateHz, actualRateHz: 0, intervalUs: 0, numSamples: 0, error: 'Device not found or type info not loaded' };
+        }
+        const typeInfo = deviceState.deviceTypeInfo;
+        // Find the _conf.rate action
+        const confRateAction = (_a = typeInfo.actions) === null || _a === void 0 ? void 0 : _a.find(a => a.n === '_conf.rate');
+        if (!(confRateAction === null || confRateAction === void 0 ? void 0 : confRateAction.map)) {
+            // No _conf.rate action — use generic sample rate setting
+            // Non-FIFO devices: poll once per sample period, 1 sample per read
+            const samplePeriodUs = Math.round(1000000 / sampleRateHz);
+            const numSamples = (_b = options === null || options === void 0 ? void 0 : options.numSamples) !== null && _b !== void 0 ? _b : 1;
+            const intervalUs = (_c = options === null || options === void 0 ? void 0 : options.intervalUs) !== null && _c !== void 0 ? _c : Math.max(5000, samplePeriodUs);
+            const { bus: devBus, addr: devAddr } = this.parseDeviceKeyForCommand(deviceKey);
+            const cmd = `devman/devconfig?bus=${devBus}&addr=${devAddr}&intervalUs=${intervalUs}&numSamples=${numSamples}`;
+            try {
+                const msgHandler = (_d = this._systemUtils) === null || _d === void 0 ? void 0 : _d.getMsgHandler();
+                if (!msgHandler) {
+                    return { ok: false, requestedRateHz: sampleRateHz, actualRateHz: sampleRateHz, intervalUs, numSamples, error: 'No message handler available' };
+                }
+                const msgRslt = await msgHandler.sendRICRESTURL(cmd);
+                const ok = msgRslt.rslt === 'ok';
+                return { ok, requestedRateHz: sampleRateHz, actualRateHz: sampleRateHz, intervalUs, numSamples, error: ok ? undefined : `Firmware returned: ${msgRslt.rslt}` };
+            }
+            catch (error) {
+                return { ok: false, requestedRateHz: sampleRateHz, actualRateHz: sampleRateHz, intervalUs, numSamples, error: `${error}` };
+            }
+        }
+        // Find the closest supported rate from the map keys
+        const supportedRates = Object.keys(confRateAction.map).map(Number).filter(r => !isNaN(r)).sort((a, b) => a - b);
+        if (supportedRates.length === 0) {
+            return { ok: false, requestedRateHz: sampleRateHz, actualRateHz: 0, intervalUs: 0, numSamples: 0, error: 'No valid rates in _conf.rate map' };
+        }
+        let actualRate = supportedRates[0];
+        let minDist = Math.abs(sampleRateHz - actualRate);
+        for (const rate of supportedRates) {
+            const dist = Math.abs(sampleRateHz - rate);
+            if (dist < minDist) {
+                minDist = dist;
+                actualRate = rate;
+            }
+        }
+        // Look up map entry for the matched rate — may be object with recommended polling params
+        const mapEntry = confRateAction.map[String(actualRate)];
+        const mapObj = typeof mapEntry === 'object' ? mapEntry : null;
+        const recommendedIntervalUs = mapObj === null || mapObj === void 0 ? void 0 : mapObj.i;
+        const recommendedNumSamples = mapObj === null || mapObj === void 0 ? void 0 : mapObj.s;
+        // Calculate inter-sample period
+        const samplePeriodUs = Math.round(1000000 / actualRate);
+        // Calculate optimal numSamples and intervalUs
+        // Priority: explicit options > map entry recommendations > auto-calculation
+        const maxNumSamples = (_e = options === null || options === void 0 ? void 0 : options.maxNumSamples) !== null && _e !== void 0 ? _e : 20;
+        let numSamples;
+        let intervalUs;
+        if ((options === null || options === void 0 ? void 0 : options.numSamples) !== undefined && (options === null || options === void 0 ? void 0 : options.intervalUs) !== undefined) {
+            // Both explicitly specified — use as-is
+            numSamples = options.numSamples;
+            intervalUs = options.intervalUs;
+        }
+        else if ((options === null || options === void 0 ? void 0 : options.intervalUs) !== undefined) {
+            // intervalUs specified, derive numSamples from it
+            intervalUs = options.intervalUs;
+            numSamples = (_g = (_f = options === null || options === void 0 ? void 0 : options.numSamples) !== null && _f !== void 0 ? _f : recommendedNumSamples) !== null && _g !== void 0 ? _g : Math.max(1, Math.min(maxNumSamples, Math.floor(intervalUs / samplePeriodUs)));
+        }
+        else if ((options === null || options === void 0 ? void 0 : options.numSamples) !== undefined) {
+            // numSamples specified, derive intervalUs from it
+            numSamples = options.numSamples;
+            intervalUs = recommendedIntervalUs !== null && recommendedIntervalUs !== void 0 ? recommendedIntervalUs : Math.round(numSamples * samplePeriodUs * 0.8);
+        }
+        else if (recommendedIntervalUs !== undefined && recommendedNumSamples !== undefined) {
+            // Use map entry recommendations
+            intervalUs = recommendedIntervalUs;
+            numSamples = recommendedNumSamples;
+        }
+        else {
+            // Auto-calculate: target ~50ms poll interval, bounded by sample rate
+            const targetPollIntervalUs = 50000;
+            numSamples = recommendedNumSamples !== null && recommendedNumSamples !== void 0 ? recommendedNumSamples : Math.max(1, Math.min(maxNumSamples, Math.floor(targetPollIntervalUs / samplePeriodUs)));
+            intervalUs = recommendedIntervalUs !== null && recommendedIntervalUs !== void 0 ? recommendedIntervalUs : Math.max(5000, Math.min(1000000, Math.round(numSamples * samplePeriodUs * 0.8)));
+        }
+        // Send single devconfig call with all parameters
+        const { bus: devBus, addr: devAddr } = this.parseDeviceKeyForCommand(deviceKey);
+        const cmd = `devman/devconfig?bus=${devBus}&addr=${devAddr}&sampleRateHz=${actualRate}&intervalUs=${intervalUs}&numSamples=${numSamples}`;
+        try {
+            const msgHandler = (_h = this._systemUtils) === null || _h === void 0 ? void 0 : _h.getMsgHandler();
+            if (!msgHandler) {
+                return { ok: false, requestedRateHz: sampleRateHz, actualRateHz: actualRate, intervalUs, numSamples, error: 'No message handler available' };
+            }
+            const msgRslt = await msgHandler.sendRICRESTURL(cmd);
+            const ok = msgRslt.rslt === 'ok';
+            return { ok, requestedRateHz: sampleRateHz, actualRateHz: actualRate, intervalUs, numSamples, error: ok ? undefined : `Firmware returned: ${msgRslt.rslt}` };
+        }
+        catch (error) {
+            return { ok: false, requestedRateHz: sampleRateHz, actualRateHz: actualRate, intervalUs, numSamples, error: `${error}` };
+        }
+    }
+    ////////////////////////////////////////////////////////////////////////////
     // Convert hex to bytes
     ////////////////////////////////////////////////////////////////////////////
     hexToBytes(hex) {
@@ -591,6 +1050,57 @@ class DeviceManager {
         return bytes;
     }
     ////////////////////////////////////////////////////////////////////////////
+    // Helpers for device stats
+    ////////////////////////////////////////////////////////////////////////////
+    createEmptyStats() {
+        return {
+            totalSamples: 0,
+            windowMs: this._statsWindowMs,
+            windowSamples: 0,
+            sampleRateHz: 0,
+            lastSampleTimeMs: null,
+            lastUpdateTimeMs: null,
+            windowEvents: []
+        };
+    }
+    getOrCreateDeviceStats(deviceKey) {
+        if (!this._deviceStats[deviceKey]) {
+            this._deviceStats[deviceKey] = this.createEmptyStats();
+        }
+        return this._deviceStats[deviceKey];
+    }
+    cloneDeviceStats(stats) {
+        return {
+            totalSamples: stats.totalSamples,
+            windowMs: stats.windowMs,
+            windowSamples: stats.windowSamples,
+            sampleRateHz: stats.sampleRateHz,
+            lastSampleTimeMs: stats.lastSampleTimeMs,
+            lastUpdateTimeMs: stats.lastUpdateTimeMs
+        };
+    }
+    updateDeviceStats(deviceKey, newSamples, nowMs) {
+        const stats = this.getOrCreateDeviceStats(deviceKey);
+        stats.lastUpdateTimeMs = nowMs;
+        if (newSamples > 0) {
+            stats.totalSamples += newSamples;
+            stats.lastSampleTimeMs = nowMs;
+            stats.windowEvents.push({ timeMs: nowMs, samples: newSamples });
+        }
+        const windowStartMs = nowMs - stats.windowMs;
+        while (stats.windowEvents.length > 0 && stats.windowEvents[0].timeMs < windowStartMs) {
+            stats.windowEvents.shift();
+        }
+        const windowSamples = stats.windowEvents.reduce((sum, entry) => sum + entry.samples, 0);
+        stats.windowSamples = windowSamples;
+        if (stats.windowEvents.length === 0) {
+            stats.sampleRateHz = 0;
+            return;
+        }
+        const actualWindowMs = Math.max(1, nowMs - stats.windowEvents[0].timeMs);
+        stats.sampleRateHz = (windowSamples * 1000) / actualWindowMs;
+    }
+    ////////////////////////////////////////////////////////////////////////////
     // Helpers for decoded data callbacks
     ////////////////////////////////////////////////////////////////////////////
     snapshotAttrLengths(deviceAttrs, pollRespMetadata) {
@@ -599,8 +1109,8 @@ class DeviceManager {
             return lengths;
         }
         pollRespMetadata.a.forEach((attr) => {
-            var _a;
-            lengths[attr.n] = ((_a = deviceAttrs[attr.n]) === null || _a === void 0 ? void 0 : _a.values.length) || 0;
+            var _a, _b;
+            lengths[attr.n] = (_b = (_a = deviceAttrs[attr.n]) === null || _a === void 0 ? void 0 : _a.values.length) !== null && _b !== void 0 ? _b : 0;
         });
         return lengths;
     }
@@ -611,11 +1121,12 @@ class DeviceManager {
         const attrValues = {};
         let hasValues = false;
         pollRespMetadata.a.forEach((attr) => {
+            var _a;
             const attrState = deviceState.deviceAttributes[attr.n];
             if (!attrState) {
                 return;
             }
-            const prevLen = attrLengthsBefore[attr.n] || 0;
+            const prevLen = (_a = attrLengthsBefore[attr.n]) !== null && _a !== void 0 ? _a : 0;
             if (attrState.values.length > prevLen) {
                 attrValues[attr.n] = attrState.values.slice(prevLen);
                 hasValues = hasValues || attrValues[attr.n].length > 0;