@robotical/raftjs 2.1.0 → 2.1.3

package/src/RaftDeviceMgrIF.ts

@@ -7,14 +7,16 @@
 //
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-import { DeviceTypeAction } from "./RaftDeviceInfo";
-import { DeviceAttributeState, DevicesState, DeviceState } from "./RaftDeviceStates";
+import { DeviceTypeAction, SampleRateResult } from "./RaftDeviceInfo";
+import { DeviceAttributeState, DevicesState, DeviceState, DeviceStats } from "./RaftDeviceStates";
 
 export default interface RaftDeviceMgrIF {
 
     // Get state of devices
     getDevicesState(): DevicesState;
     getDeviceState(deviceKey: string): DeviceState;
+    getDeviceStats(deviceKey: string): DeviceStats;
+    resetDeviceStats(deviceKey: string): void;
 
     // Settings
     setMaxDataPointsToStore(maxDataPointsToStore: number): void;
@@ -26,8 +28,17 @@ export default interface RaftDeviceMgrIF {
     removeNewAttributeCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void;
     addAttributeDataCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void;
     removeAttributeDataCallback(callback: (deviceKey: string, attrState: DeviceAttributeState) => void): void;
+    addDeviceRemovedCallback(callback: (deviceKey: string, state: DeviceState) => void): void;
+    removeDeviceRemovedCallback(callback: (deviceKey: string, state: DeviceState) => void): void;
 
     // Send action to device
     sendAction(deviceKey: string, action: DeviceTypeAction, data: number[]): void;
     sendCompoundAction(deviceKey: string, action: DeviceTypeAction, data: number[][]): void;
+
+    // Set sample rate with coordinated polling parameters
+    setSampleRate(deviceKey: string, sampleRateHz: number, options?: {
+        numSamples?: number;
+        intervalUs?: number;
+        maxNumSamples?: number;
+    }): Promise<SampleRateResult>;
 }

package/src/RaftDeviceStates.ts

@@ -14,10 +14,14 @@ export function deviceAttrGetLatestFormatted(attrState: DeviceAttributeState): s
     if (attrState.values.length === 0) {
         return 'N/A';
     }
+    const value = attrState.values[attrState.values.length - 1];
+    // String values are returned directly
+    if (typeof value === 'string') {
+        return value;
+    }
     if (attrState.format.length === 0) {
-        return attrState.values[attrState.values.length - 1].toString();
+        return value.toString();
     }
-    const value = attrState.values[attrState.values.length - 1];
     let format = attrState.format;
     if (format.startsWith("%")) {
         format = format.slice(1);
@@ -52,7 +56,7 @@ export interface DeviceAttributeState {
     newAttribute: boolean;
     newData: boolean;
     numNewValues: number;
-    values: number[];
+    values: (number | string)[];
     units: string;
     range: number[];
     format: string;
@@ -68,15 +72,37 @@ export interface DeviceTimeline {
     timestampsUs: number[];
     lastReportTimestampUs: number;
     reportTimestampOffsetUs: number;
+    totalSamplesAdded: number;
+    // Piecewise EMA timestamp reconstruction state
+    emaLastSampleTimeUs: number;
+    emaIntervalUs: number;
+    emaPrevPollTimeUs: number;
+    emaCalibrated: boolean;
+    emaCalibrationPolls: number;
+}
+
+export interface DeviceStats {
+    totalSamples: number;
+    windowMs: number;
+    windowSamples: number;
+    sampleRateHz: number;
+    lastSampleTimeMs: number | null;
+    lastUpdateTimeMs: number | null;
+}
+
+export enum DeviceOnlineState {
+    Offline = 0,
+    Online = 1,
+    PendingDeletion = 2,
 }
-    
+
 export interface DeviceState {
     deviceTypeInfo: DeviceTypeInfo | undefined;
     deviceTimeline: DeviceTimeline;
     deviceAttributes: DeviceAttributesState;
     deviceIsNew: boolean;
     stateChanged: boolean;
-    isOnline: boolean;
+    onlineState: DeviceOnlineState;
     deviceAddress: string;
     deviceType: string;
     busName: string;
@@ -86,7 +112,22 @@ export class DevicesState {
     [deviceKey: string]: DeviceState;
 }
 
-// Add the getDeviceKey method to generate a composite key
-export function getDeviceKey(busName: string, devAddr: string, devType: string): string {
-    return `${busName}_${devAddr}_${devType}`;
+// Format a numeric device address as canonical hex string:
+// lowercase, no "0x" prefix, no leading zeros
+export function formatDeviceAddrHex(addr: number): string {
+    return addr.toString(16);
+}
+
+// Generate a composite device key from bus number and hex address
+export function getDeviceKey(busNumberAsString: string, devAddrHexStr: string): string {
+    return `${busNumberAsString}_${devAddrHexStr}`;
+}
+
+// Parse a device key into its bus and address components
+export function parseDeviceKey(deviceKey: string): { bus: string; addr: string } {
+    const sep = deviceKey.indexOf('_');
+    if (sep < 0) {
+        return { bus: deviceKey, addr: '' };
+    }
+    return { bus: deviceKey.substring(0, sep), addr: deviceKey.substring(sep + 1) };
 }

package/src/RaftFileHandler.ts

@@ -13,6 +13,7 @@ import RaftMsgHandler from './RaftMsgHandler';
 import {
   RaftFileDownloadResult,
   RaftFileDownloadStartResp,
+  RaftFileDownloadEndResp,
   RaftFileSendType,
   RaftFileStartResp,
   RaftOKFail,
@@ -64,6 +65,7 @@ export default class RaftFileHandler {
   private _ackedFilePos = 0;
   private _batchAckReceived = false;
   private _isTxCancelled = false;
+  private _fileTxStreamID = 0;
 
   // File receive info
   private _isRxCancelled = false;
@@ -77,7 +79,6 @@ export default class RaftFileHandler {
   private _fileRxLastAckTime = 0;
   private _fileRxLastBlockTime = 0;
   private _fileRxLastAckPos = 0;
-  private OVERALL_FILE_TRANSFER_TIMEOUT_MS = 100000;
   private FILE_RX_ACK_RESEND_TIMEOUT_MS = 1000;
 
   // RaftCommsStats
@@ -110,6 +111,7 @@ export default class RaftFileHandler {
     progressCallback: ((sent: number, total: number, progress: number) => void) | undefined,
   ): Promise<boolean> {
     this._isTxCancelled = false;
+    this._fileTxStreamID = 0;
 
     // Send file start message
     if (!await this._sendFileStartMsg(fileName, fileType, fileDest, fileContents))
@@ -165,8 +167,8 @@ export default class RaftFileHandler {
       RaftLog.warn(`sendFileStartMsg error ${err}`);
       return false;
     }
-    if (fileStartResp.rslt !== 'ok') {
-      RaftLog.warn(`sendFileStartMsg error ${fileStartResp.rslt}`);
+    if (!fileStartResp || fileStartResp.rslt !== 'ok') {
+      RaftLog.warn(`sendFileStartMsg error ${fileStartResp?.rslt ?? 'no response'}`);
       return false;
     }
 
@@ -181,12 +183,17 @@ export default class RaftFileHandler {
     } else {
       this._batchAckSize = this._requestedBatchAckSize;
     }
+    const streamID = fileStartResp.streamID;
+    this._fileTxStreamID = streamID !== undefined && streamID > 0 && streamID <= 0xff ? streamID : 0;
     RaftLog.debug(
       `_fileSendStartMsg fileBlockSize req ${this._requestedFileBlockSize} resp ${fileStartResp.batchMsgSize} actual ${this._fileBlockSize}`,
     );
     RaftLog.debug(
       `_fileSendStartMsg batchAckSize req ${this._requestedBatchAckSize} resp ${fileStartResp.batchAckSize} actual ${this._batchAckSize}`,
     );
+    RaftLog.debug(
+      `_fileSendStartMsg streamID ${this._fileTxStreamID}`,
+    );
     return true;
   }
 
@@ -202,7 +209,8 @@ export default class RaftFileHandler {
         ? 'espfwupdate'
         : 'fileupload';
     const fileLen = fileContents.length;
-    const cmdMsg = `{"cmdName":"ufEnd","reqStr":"${reqStr}","fileType":"${fileDest}","fileName":"${fileName}","fileLen":${fileLen}}`;
+    const streamIDJson = this._fileTxStreamID !== 0 ? `,"streamID":${this._fileTxStreamID}` : '';
+    const cmdMsg = `{"cmdName":"ufEnd","reqStr":"${reqStr}","fileType":"${fileDest}","fileName":"${fileName}","fileLen":${fileLen}${streamIDJson}}`;
 
     // Await outstanding promises
     try {
@@ -223,12 +231,13 @@ export default class RaftFileHandler {
       RaftLog.warn(`sendFileEndMsg error ${err}`);
       return false;
     }
-    return fileEndResp.rslt === 'ok';
+    return fileEndResp?.rslt === 'ok';
   }
 
   async _sendFileCancelMsg(): Promise<void> {
     // File cancel command message
-    const cmdMsg = `{"cmdName":"ufCancel"}`;
+    const streamIDJson = this._fileTxStreamID !== 0 ? `,"streamID":${this._fileTxStreamID}` : '';
+    const cmdMsg = `{"cmdName":"ufCancel"${streamIDJson}}`;
 
     // Await outstanding promises
     await this.awaitOutstandingMsgPromises(true);
@@ -367,7 +376,7 @@ export default class RaftFileHandler {
     await this.awaitOutstandingMsgPromises(false);
 
     // Send
-    const promRslt = this._msgHandler.sendFileBlock(fileContents.subarray(blockStart, blockEnd), blockStart);
+    const promRslt = this._msgHandler.sendFileBlock(fileContents.subarray(blockStart, blockEnd), blockStart, this._fileTxStreamID);
     if (!promRslt) {
       return false;
     }
@@ -437,8 +446,8 @@ export default class RaftFileHandler {
       // Establish a bridge
       const bridgedDeviceSerialPort = "Serial" + fileSource.slice(bridgeSerialPrefix.length);
       const cmdResp = await this._msgHandler.createCommsBridge(bridgedDeviceSerialPort, "fileSource");
-      if (cmdResp.rslt != "ok") {
-        RaftLog.warn(`fileReceive - failed to setup bridge ${cmdResp.rslt}`);
+      if (!cmdResp || cmdResp.rslt != "ok") {
+        RaftLog.warn(`fileReceive - failed to setup bridge ${cmdResp?.rslt ?? 'no response'}`);
         return new RaftFileDownloadResult();
       }
       bridgeID = cmdResp.bridgeID;
@@ -454,8 +463,9 @@ export default class RaftFileHandler {
     // Send contents
     const fileContents = await this._receiveFileContents(progressCallback, bridgeID);
 
-    // Send file end
-    await this._receiveFileEnd(fileName, bridgeID);
+    // Send file end (and verify deferred CRC if applicable)
+    if (!await this._receiveFileEnd(fileName, bridgeID))
+      return new RaftFileDownloadResult();
 
     // Clean up
     await this.awaitOutstandingMsgPromises(true);
@@ -471,14 +481,16 @@ export default class RaftFileHandler {
   async _receiveFileStart(fileName: string, bridgeID: number | undefined) : Promise<boolean> {
 
     const blockMaxSizeRequested = 5000;
-    const batchAckSizeRequested = 10;
+    const batchAckSizeRequested = 4;
     const fileSrc = "fs";
 
     // Request file transfer
     // Frames follow the approach used in the web interface start, block..., end
+    // crcAt:end requests the server to defer CRC computation (non-blocking start)
     const cmdMsg = `{"cmdName":"dfStart","reqStr":"getFile","fileType":"${fileSrc}",` +
                     `"batchMsgSize":${blockMaxSizeRequested},` +
                     `"batchAckSize":${batchAckSizeRequested},` +
+                    `"crcAt":"end",` +
                     `"fileName":"${fileName}"}`
 
     // Send
@@ -494,18 +506,23 @@ export default class RaftFileHandler {
       return false;
     }
     RaftLog.info(`_receiveFileStartMsg rslt ${JSON.stringify(cmdResp)}`);
-    if (cmdResp.rslt === 'ok') {
+    if (cmdResp?.rslt === 'ok') {
       this._fileRxBatchMsgSize = cmdResp.batchMsgSize;
       this._fileRxBatchAckSize = cmdResp.batchAckSize;
       this._fileRxStreamID = cmdResp.streamID;
       this._fileRxFileLen = cmdResp.fileLen;
-      this._fileRxCrc16 = parseInt(cmdResp.crc16, 16);
+      // CRC may be provided at start (old firmware) or deferred to dfEnd (new firmware)
+      this._fileRxCrc16 = cmdResp.crc16 ? parseInt(cmdResp.crc16, 16) : -1;
       this._fileRxBuffer = new Uint8Array(0);
       this._fileRxLastAckTime = 0;
       this._fileRxLastAckPos = 0;
       this._fileRxLastBlockTime = Date.now();
       this._fileRxActive = true;
     }
+    if (!cmdResp) {
+      RaftLog.warn(`_receiveFileStartMsg failed no response`);
+      return false;
+    }
     return cmdResp.rslt === 'ok';
   }
 
@@ -514,6 +531,18 @@ export default class RaftFileHandler {
         bridgeID: number | undefined
   ): Promise<RaftFileDownloadResult> {
 
+    // Calculate dynamic timeouts based on file size and connection speed
+    // Use batch message size as proxy for connection type:
+    //   BLE ~500 byte blocks ~5 KB/s, WebSocket ~5000 byte blocks ~50 KB/s
+    const estimatedBytesPerSec = this._fileRxBatchMsgSize <= 500 ? 5000 : 50000;
+    const BASE_TIMEOUT_MS = 30000;
+    const SAFETY_FACTOR = 2;
+    const transferTimeMs = (this._fileRxFileLen / estimatedBytesPerSec) * 1000 * SAFETY_FACTOR;
+    const overallTimeoutMs = BASE_TIMEOUT_MS + transferTimeMs;
+    const blockTimeoutMs = this.BLOCK_ACK_TIMEOUT_MS;
+    RaftLog.info(`_receiveFileContents - fileLen ${this._fileRxFileLen} batchMsgSize ${this._fileRxBatchMsgSize} ` +
+        `estimatedBytesPerSec ${estimatedBytesPerSec} overallTimeoutMs ${overallTimeoutMs} blockTimeoutMs ${blockTimeoutMs}`);
+
     // Wait for file to be received
     return new Promise<RaftFileDownloadResult>((resolve, reject) => {
       const startTime = Date.now();
@@ -527,14 +556,16 @@ export default class RaftFileHandler {
             progressCallback(this._fileRxBuffer.length, this._fileRxFileLen);
           }
 
-          // Check CRC
-          const crc16 = RaftMiniHDLC.crc16(this._fileRxBuffer);
-          if (crc16 !== this._fileRxCrc16) {
-            RaftLog.warn(`_receiveFileContents - CRC error ${crc16} ${this._fileRxCrc16}`);
-            reject(new Error('fileReceive CRC error'));
-            return;
-          } else {
-            RaftLog.info(`_receiveFileContents - CRC OK ${crc16} ${this._fileRxCrc16}`);
+          // Check CRC if it was provided at start (old firmware)
+          if (this._fileRxCrc16 >= 0) {
+            const crc16 = RaftMiniHDLC.crc16(this._fileRxBuffer);
+            if (crc16 !== this._fileRxCrc16) {
+              RaftLog.warn(`_receiveFileContents - CRC error ${crc16} ${this._fileRxCrc16}`);
+              reject(new Error('fileReceive CRC error'));
+              return;
+            } else {
+              RaftLog.info(`_receiveFileContents - CRC OK ${crc16} ${this._fileRxCrc16}`);
+            }
           }
           resolve(new RaftFileDownloadResult(this._fileRxBuffer));
           return;
@@ -556,10 +587,13 @@ export default class RaftFileHandler {
         const now = Date.now();
 
         // Check for overall timeouts
-        if ((now - startTime > this.OVERALL_FILE_TRANSFER_TIMEOUT_MS) || 
-            (now - this._fileRxLastBlockTime > this.BLOCK_ACK_TIMEOUT_MS)) {
-          RaftLog.warn(`_receiveFileContents - time-out no new data received`);
+        if ((now - startTime > overallTimeoutMs) ||
+            (now - this._fileRxLastBlockTime > blockTimeoutMs)) {
+          RaftLog.warn(`_receiveFileContents - time-out no new data received ` +
+              `elapsed ${now - startTime}ms overallTimeout ${overallTimeoutMs}ms ` +
+              `blockGap ${now - this._fileRxLastBlockTime}ms blockTimeout ${blockTimeoutMs}ms`);
           this._fileRxActive = false;
+          this._sendFileRxCancelMsg(bridgeID);
           reject(new Error('fileReceive failed'));
           return;
         }
@@ -574,7 +608,7 @@ export default class RaftFileHandler {
         if (this._fileRxBuffer.length - this._fileRxLastAckPos >= this._fileRxBatchAckSize * this._fileRxBatchMsgSize) {
           ackRequired = true;
         }
-        // RaftLog.info(`_receiveFileContents ${ackRequired ? "ACK_REQUIRED" : "ACK_NOTREQUIRED"}  ${this._fileRxBuffer.length} ${this._fileRxLastAckPos} ${this._fileRxBatchAckSize} ${this._fileRxBatchMsgSize}`); 
+        // RaftLog.info(`_receiveFileContents ${ackRequired ? "ACK_REQUIRED" : "ACK_NOTREQUIRED"}  ${this._fileRxBuffer.length} ${this._fileRxLastAckPos} ${this._fileRxBatchAckSize} ${this._fileRxBatchMsgSize}`);
 
         // Check if ack required
         if (ackRequired) {
@@ -582,7 +616,7 @@ export default class RaftFileHandler {
           // Ack timing
           this._fileRxLastAckTime = Date.now();
           this._fileRxLastAckPos = this._fileRxBuffer.length;
-    
+
           // Okto message
           const cmdMsg = `{"cmdName":"dfAck","okto":${this._fileRxBuffer.length},` +
                         `"streamID":${this._fileRxStreamID},"rslt":"ok"}`;
@@ -612,18 +646,45 @@ export default class RaftFileHandler {
 
   async _receiveFileEnd(fileName: string, bridgeID: number | undefined): Promise<boolean> {
 
-    // Send file end message
-    const cmdMsg = `{"cmdName":"dfAck","reqStr":"getFile","okto":${this._fileRxBuffer.length},` +
-          `"fileName":"${fileName}","streamID":${this._fileRxStreamID},"rslt":"ok"}`
-    this._msgHandler.sendRICRESTNoResp(
-      cmdMsg,
-      RICRESTElemCode.RICREST_ELEM_CODE_COMMAND_FRAME,
-      bridgeID
-    );
+    // Send dfEnd and wait for response (may contain deferred CRC)
+    const cmdMsg = `{"cmdName":"dfEnd","reqStr":"getFile",` +
+          `"fileName":"${fileName}","fileLen":${this._fileRxBuffer.length},` +
+          `"streamID":${this._fileRxStreamID}}`
+
+    let cmdResp = null;
+    try {
+      cmdResp = await this._msgHandler.sendRICREST<RaftFileDownloadEndResp>(
+        cmdMsg,
+        RICRESTElemCode.RICREST_ELEM_CODE_COMMAND_FRAME,
+        bridgeID,
+      );
+    } catch (err) {
+      RaftLog.warn(`_receiveFileEnd error ${err}`);
+      this._fileRxActive = false;
+      return false;
+    }
+
+    // Check deferred CRC if start response didn't include one
+    if (!cmdResp) {
+      RaftLog.warn(`_receiveFileEnd failed no response`);
+      this._fileRxActive = false;
+      return false;
+    }
+
+    if (this._fileRxCrc16 < 0 && cmdResp.crc16) {
+      const expectedCrc = parseInt(cmdResp.crc16, 16);
+      const actualCrc = RaftMiniHDLC.crc16(this._fileRxBuffer);
+      if (actualCrc !== expectedCrc) {
+        RaftLog.warn(`_receiveFileEnd - CRC error actual=${actualCrc} expected=${expectedCrc}`);
+        this._fileRxActive = false;
+        return false;
+      }
+      RaftLog.info(`_receiveFileEnd - CRC OK ${actualCrc}`);
+    }
 
     // No longer active
     this._fileRxActive = false;
-    return false;
+    return true;
   }
 
   async _sendFileRxCancelMsg(bridgeID: number | undefined): Promise<void> {
@@ -642,8 +703,20 @@ export default class RaftFileHandler {
   ): void {
     // RaftLog.info(`onFileBlock filePos ${filePos} fileBlockData ${RaftUtils.bufferToHex(fileBlockData)}`);
 
+    if (!this._fileRxActive) {
+      RaftLog.verbose(`onFileBlock ignored inactive transfer filePos ${filePos} len ${fileBlockData.length}`);
+      return;
+    }
+
+    const streamID = (filePos >>> 24) & 0xff;
+    const streamFilePos = filePos & 0x00ffffff;
+    if (streamID !== 0 && streamID !== this._fileRxStreamID) {
+      RaftLog.verbose(`onFileBlock ignored stale streamID ${streamID} active ${this._fileRxStreamID}`);
+      return;
+    }
+
     // Check if this is the next block we are expecting
-    if (filePos === this._fileRxBuffer.length) {
+    if (streamFilePos === this._fileRxBuffer.length) {
 
       // Add to buffer
       const tmpArray = new Uint8Array(this._fileRxBuffer.length + fileBlockData.length);
@@ -658,11 +731,11 @@ export default class RaftFileHandler {
       // RaftLog.info(`onFileBlock filePos ${filePos} fileBlockData ${RaftUtils.bufferToHex(fileBlockData)} added to buffer`);
 
     } else {
-      RaftLog.warn(`onFileBlock expected streamID ${this._fileRxStreamID} filePos ${filePos} fileBlockData ${RaftUtils.bufferToHex(fileBlockData)} out of sequence`);
+      RaftLog.warn(`onFileBlock expected streamID ${this._fileRxStreamID} filePos ${streamFilePos} fileBlockData ${RaftUtils.bufferToHex(fileBlockData)} out of sequence`);
     }
   }
 
   isFileRxActive(): boolean {
     return this._fileRxActive;
   }
-}
+}

package/src/RaftMicroPythonConsoleClient.ts

@@ -0,0 +1,78 @@
+import RaftConnector from "./RaftConnector";
+import { RaftRtStreamDataCBType, RaftRtStreamHandle } from "./RaftTypes";
+
+const REPL_NEWLINE = "\r";
+
+export type RaftMicroPythonConsoleStatus = {
+  rslt?: string;
+  running?: string;
+  replEnabled?: boolean;
+  replRunning?: boolean;
+  mode?: string;
+  streamAttached?: boolean;
+  mirrorToSerial?: boolean;
+  inputBuffered?: number;
+  outputBuffered?: number;
+  outputSeq?: number;
+  inputDropped?: number;
+  outputDropped?: number;
+};
+
+export type RaftMicroPythonConsoleOutput = {
+  rslt?: string;
+  seq?: number;
+  missed?: number;
+  dropped?: number;
+  data?: string;
+};
+
+export default class RaftMicroPythonConsoleClient {
+  constructor(private _connector: RaftConnector) {}
+  private readonly _streamDrainMs = 1200;
+
+  async status(): Promise<RaftMicroPythonConsoleStatus> {
+    return this._connector.sendRICRESTMsg("upy/repl/status", {}) as Promise<RaftMicroPythonConsoleStatus>;
+  }
+
+  async output(since: number): Promise<RaftMicroPythonConsoleOutput> {
+    return this._connector.sendRICRESTMsg("upy/repl/output", { since }) as Promise<RaftMicroPythonConsoleOutput>;
+  }
+
+  async input(data: string, newline = true): Promise<{ rslt?: string }> {
+    const payload = newline ? `${data}${REPL_NEWLINE}` : data;
+    return this._connector.sendRICRESTMsg(
+      `upy/repl/input?data=${payload}&newline=0`,
+      {}
+    ) as Promise<{ rslt?: string }>;
+  }
+
+  async interrupt(): Promise<{ rslt?: string }> {
+    return this._connector.sendRICRESTMsg("upy/repl/interrupt", {}) as Promise<{ rslt?: string }>;
+  }
+
+  async openStream(onData: RaftRtStreamDataCBType): Promise<RaftRtStreamHandle> {
+    return this._connector.openRtStream({
+      fileName: "upyconsole",
+      endpoint: "upyconsole",
+      onData,
+    });
+  }
+
+  async streamInput(
+    data: string,
+    newline = true,
+    onData: RaftRtStreamDataCBType = () => {}
+  ): Promise<boolean> {
+    const payload = newline ? `${data}${REPL_NEWLINE}` : data;
+    const streamHandle = await this.openStream(onData);
+    try {
+      return await streamHandle.sendText(payload);
+    } finally {
+      setTimeout(() => {
+        streamHandle.close().catch(() => {
+          // The firmware may close short-lived console sessions first.
+        });
+      }, this._streamDrainMs);
+    }
+  }
+}

package/src/RaftMsgHandler.ts

@@ -269,8 +269,11 @@ export default class RaftMsgHandler {
         }
 
       } else {
-        RaftLog.warn(
-          `_handleResponseMessages RICREST response doesn't contain rslt ${rxMsgNum == 0 ? "unnumbered" : "msgNum " + rxMsgNum.toString()}resp ${restStr}`,
+        // Some REST APIs return data-only JSON, including an empty object, with no rslt field.
+        // Treat parseable JSON as a successful transport response and let callers interpret it.
+        msgRsltCode = RaftMsgResultCode.MESSAGE_RESULT_OK;
+        RaftLog.verbose(
+          `_handleResponseMessages RICREST response without rslt ${rxMsgNum == 0 ? "unnumbered" : "msgNum " + rxMsgNum.toString()} resp ${restStr}`,
         );
       }
 
@@ -726,9 +729,10 @@ export default class RaftMsgHandler {
 
   async sendFileBlock(
     blockContents: Uint8Array,
-    blockStart: number
+    blockStart: number,
+    streamID = 0,
   ): Promise<boolean> {
-    const msgBuf = this.encodeFileStreamBlock(blockContents, blockStart, 0);
+    const msgBuf = this.encodeFileStreamBlock(blockContents, blockStart, streamID);
 
     // // Debug
     // RaftLog.debug(

package/src/RaftPublish.ts

@@ -0,0 +1,92 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// RaftSystem
+// Part of RaftJS
+//
+// Rob Dobson 2025
+// (C) 2020-2025 All rights reserved
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+import { RaftPublishFrameMeta } from "./RaftTypes";
+
+const RAFT_PUBLISH_PREFIX_LEN = 2;
+const DEVBIN_MAGIC_MIN = 0xDB;
+const DEVBIN_MAGIC_MAX = 0xDF;
+const DEVBIN_VERSION_BASE = 0xDA;
+
+export function inspectPublishFrame(
+  payload: Uint8Array,
+  topicLookup?: (topicIndex: number) => string | undefined,
+): RaftPublishFrameMeta {
+
+  if (payload.length < RAFT_PUBLISH_PREFIX_LEN) {
+    return { frameType: "unknown" };
+  }
+
+  const payloadStartPos = RAFT_PUBLISH_PREFIX_LEN;
+  if (payload.length <= payloadStartPos) {
+    return { frameType: "unknown" };
+  }
+
+  // Try JSON first
+  if (payload[payloadStartPos] === 0x7B) {
+    try {
+      const jsonString = new TextDecoder("utf-8").decode(payload.slice(payloadStartPos));
+      const jsonObj = JSON.parse(jsonString) as Record<string, unknown>;
+
+      let topicIndex: number | undefined = undefined;
+      let topicName: string | undefined = undefined;
+      if (typeof jsonObj._t === "number") {
+        topicIndex = jsonObj._t;
+        topicName = topicLookup ? topicLookup(topicIndex) : undefined;
+      } else if (typeof jsonObj._t === "string") {
+        topicName = jsonObj._t;
+      }
+
+      const version = typeof jsonObj._v === "number" ? jsonObj._v : undefined;
+
+      return {
+        frameType: "json",
+        topicIndex,
+        topicName,
+        version,
+        jsonString,
+      };
+    } catch {
+      return { frameType: "unknown" };
+    }
+  }
+
+  // Binary (devbin legacy or enveloped)
+  const firstBinaryByte = payload[payloadStartPos];
+  if ((firstBinaryByte & 0xF0) === 0xD0) {
+    if (firstBinaryByte < DEVBIN_MAGIC_MIN || firstBinaryByte > DEVBIN_MAGIC_MAX) {
+      return {
+        frameType: "binary",
+        binaryHasEnvelope: true,
+      };
+    }
+
+    const topicIndex = payload.length > payloadStartPos + 1 ? payload[payloadStartPos + 1] : undefined;
+    const topicName = (topicIndex !== undefined && topicIndex !== 0xFF && topicLookup)
+      ? topicLookup(topicIndex)
+      : undefined;
+
+    return {
+      frameType: "binary",
+      topicIndex,
+      topicName,
+      version: firstBinaryByte - DEVBIN_VERSION_BASE,
+      binaryHasEnvelope: true,
+      binaryPayloadOffset: payloadStartPos + 2,
+    };
+  }
+
+  // Legacy binary format (no envelope)
+  return {
+    frameType: "binary",
+    binaryHasEnvelope: false,
+    binaryPayloadOffset: payloadStartPos,
+  };
+}