@espressif/rainmaker-neo-base-sdk 1.1.0 → 1.2.0

package/dist/cjs/ESPRMNeoBase.js

@@ -185,7 +185,7 @@ class ESPRMNeoBase {
     }
     /**
      * Sets the local control adapter used to talk to nodes over the LAN via
-     * the `esp_local_ctrl` protocol.
+     * the `rmaker_local_ctrl` protocol.
      *
      * @param adapter - Adapter implementing {@link ESPLocalControlAdapterInterface}.
      * @throws {Error} If the SDK is not initialized or the adapter is invalid.

package/dist/cjs/index.js

@@ -191,7 +191,12 @@ Object.defineProperty(exports, "ESPTransport", {
 	get: function () { return provision.ESPTransport; }
 });
 exports.resolveNodeId = subscription.resolveNodeId;
+exports.DEFAULT_LOCAL_CONTROL_PROTOCOL = transport.DEFAULT_LOCAL_CONTROL_PROTOCOL;
 exports.DEFAULT_TRANSPORT_ORDER = transport.DEFAULT_TRANSPORT_ORDER;
+Object.defineProperty(exports, "ESPLocalControlProtocol", {
+	enumerable: true,
+	get: function () { return transport.ESPLocalControlProtocol; }
+});
 Object.defineProperty(exports, "ESPTransportMode", {
 	enumerable: true,
 	get: function () { return transport.ESPTransportMode; }
@@ -269,6 +274,12 @@ exports.NodeWarnMessages = constants.NodeWarnMessages;
 exports.ProtocolType = constants.ProtocolType;
 exports.ProvErrorCodes = constants.ProvErrorCodes;
 exports.ProvisionType = constants.ProvisionType;
+exports.RMAKER_LOCAL_CTRL_FRAGMENT_SIZE = constants.RMAKER_LOCAL_CTRL_FRAGMENT_SIZE;
+exports.RMAKER_LOCAL_CTRL_VERSION_KEY = constants.RMAKER_LOCAL_CTRL_VERSION_KEY;
+exports.RMakerLocalCtrlCapability = constants.RMakerLocalCtrlCapability;
+exports.RMakerLocalCtrlEndpoint = constants.RMakerLocalCtrlEndpoint;
+exports.RMakerLocalCtrlSetParamsStatus = constants.RMakerLocalCtrlSetParamsStatus;
+exports.RMakerLocalCtrlTxtKey = constants.RMakerLocalCtrlTxtKey;
 exports.SDK_VERSION = constants.SDK_VERSION;
 exports.ScheduleErrorMessages = constants.ScheduleErrorMessages;
 exports.ScheduleSuccessMessages = constants.ScheduleSuccessMessages;

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/proto/rmaker_local_ctrl.js

@@ -0,0 +1,273 @@
+'use strict';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Codec for the `rmaker_local_ctrl` endpoint protocol, mirroring the firmware's
+ * `local_ctrl.proto` schema.
+ *
+ * Hand-rolled like {@link ClaimingProtoHelper} rather than generated: the
+ * schema is small, and generated `google-protobuf` modules cannot be pulled
+ * into a downstream Metro/RN bundle (see the note in `utils/export.ts`).
+ *
+ * Field numbers are the wire contract with deployed firmware — treat them as
+ * frozen:
+ * - `RMakerLocalCtrlPayload`: 1 = msg (varint), 10 = cmdGetData, 11 = respGetData
+ * - `CmdGetData`:  1 = DataType (varint), 2 = Offset (varint),
+ *                  3 = Timestamp (varint), 4 = HasTimestamp (varint)
+ * - `RespGetData`: 1 = Status (varint), 2 = Buf
+ * - `PayloadBuf`:  1 = Offset (varint), 2 = Payload (bytes), 3 = TotalLen (varint)
+ *
+ * `Timestamp` / `HasTimestamp` are reserved for a future signed-response
+ * extension and are ignored by current firmware, so the encoder omits them.
+ *
+ * Only `get_params` / `get_config` use this schema; `set_params` carries raw
+ * JSON on the wire.
+ */
+/**
+ * Status returned by the device for a data read.
+ */
+exports.RMakerLocalCtrlStatus = void 0;
+(function (RMakerLocalCtrlStatus) {
+    RMakerLocalCtrlStatus[RMakerLocalCtrlStatus["Success"] = 0] = "Success";
+    RMakerLocalCtrlStatus[RMakerLocalCtrlStatus["Fail"] = 1] = "Fail";
+    RMakerLocalCtrlStatus[RMakerLocalCtrlStatus["InvalidParam"] = 2] = "InvalidParam";
+    RMakerLocalCtrlStatus[RMakerLocalCtrlStatus["NoMemory"] = 3] = "NoMemory";
+})(exports.RMakerLocalCtrlStatus || (exports.RMakerLocalCtrlStatus = {}));
+/**
+ * Selects which document a read targets.
+ */
+exports.RMakerLocalCtrlDataType = void 0;
+(function (RMakerLocalCtrlDataType) {
+    /** The node's params JSON, as served by `get_params`. */
+    RMakerLocalCtrlDataType[RMakerLocalCtrlDataType["TypeParams"] = 0] = "TypeParams";
+    /** The node's config JSON, as served by `get_config`. */
+    RMakerLocalCtrlDataType[RMakerLocalCtrlDataType["TypeConfig"] = 1] = "TypeConfig";
+})(exports.RMakerLocalCtrlDataType || (exports.RMakerLocalCtrlDataType = {}));
+/**
+ * Message type discriminator carried on `RMakerLocalCtrlPayload.msg`.
+ */
+exports.RMakerLocalCtrlMsgType = void 0;
+(function (RMakerLocalCtrlMsgType) {
+    RMakerLocalCtrlMsgType[RMakerLocalCtrlMsgType["TypeCmdGetData"] = 0] = "TypeCmdGetData";
+    RMakerLocalCtrlMsgType[RMakerLocalCtrlMsgType["TypeRespGetData"] = 1] = "TypeRespGetData";
+})(exports.RMakerLocalCtrlMsgType || (exports.RMakerLocalCtrlMsgType = {}));
+/** Tag bytes written by the request encoder: `(fieldNumber << 3) | wireType`. */
+const TAG_FIELD_1_VARINT = 0x08;
+const TAG_FIELD_2_VARINT = 0x10;
+const TAG_FIELD_10_BYTES = 0x52;
+const WIRE_TYPE_VARINT = 0;
+const WIRE_TYPE_BYTES = 2;
+/**
+ * Encoder/decoder for `rmaker_local_ctrl` frames.
+ */
+class RMakerLocalCtrlProtoHelper {
+    /**
+     * Builds a `CmdGetData` request for one fragment.
+     *
+     * An `offset` of 0 makes the device (re)generate and cache the document;
+     * subsequent offsets are served from that cache.
+     *
+     * @param dataType - Document to read.
+     * @param offset - Byte offset to read from.
+     * @returns The serialized request.
+     */
+    static createGetDataRequest(dataType, offset) {
+        const cmdGetData = this.concat([
+            // Both fields are written explicitly, including their proto3 zero values,
+            // matching how the reference clients frame this command.
+            new Uint8Array([TAG_FIELD_1_VARINT]),
+            this.encodeVarint(dataType),
+            new Uint8Array([TAG_FIELD_2_VARINT]),
+            this.encodeVarint(offset),
+        ]);
+        return this.concat([
+            new Uint8Array([TAG_FIELD_1_VARINT]),
+            this.encodeVarint(exports.RMakerLocalCtrlMsgType.TypeCmdGetData),
+            new Uint8Array([TAG_FIELD_10_BYTES]),
+            this.encodeVarint(cmdGetData.length),
+            cmdGetData,
+        ]);
+    }
+    /**
+     * Parses a `RespGetData` frame from the device.
+     *
+     * @param data - Raw response bytes.
+     * @returns The parsed payload. Absent fields keep their proto3 defaults.
+     */
+    static parseGetDataResponse(data) {
+        const result = {
+            msg: exports.RMakerLocalCtrlMsgType.TypeCmdGetData,
+        };
+        let index = 0;
+        while (index < data.length) {
+            const tag = data[index++];
+            const fieldNumber = tag >> 3;
+            const wireType = tag & 0x07;
+            if (fieldNumber === 1 && wireType === WIRE_TYPE_VARINT) {
+                const { value, newIndex } = this.readVarint(data, index);
+                result.msg = value;
+                index = newIndex;
+                continue;
+            }
+            if (fieldNumber === 11 && wireType === WIRE_TYPE_BYTES) {
+                const { value: length, newIndex } = this.readVarint(data, index);
+                result.respGetData = this.parseRespGetData(data.slice(newIndex, newIndex + length));
+                index = newIndex + length;
+                continue;
+            }
+            index = this.skipField(data, index, wireType);
+        }
+        return result;
+    }
+    /**
+     * Whether the device reported a successful read.
+     *
+     * @param response - Parsed response.
+     */
+    static isSuccess(response) {
+        return response.respGetData?.status === exports.RMakerLocalCtrlStatus.Success;
+    }
+    /**
+     * Returns the device's status as its enum name, for diagnostics.
+     *
+     * @param response - Parsed response.
+     * @returns The status name, or `"Unknown"` when absent.
+     */
+    static getStatus(response) {
+        const status = response.respGetData?.status;
+        return status === undefined
+            ? "Unknown"
+            : (exports.RMakerLocalCtrlStatus[status] ?? `Unknown(${status})`);
+    }
+    /**
+     * Offset the device answered with, which must match the requested offset.
+     *
+     * @param response - Parsed response.
+     */
+    static getOffset(response) {
+        return response.respGetData?.buf?.offset ?? 0;
+    }
+    /**
+     * Full document length reported by the device.
+     *
+     * @param response - Parsed response.
+     */
+    static getTotalLen(response) {
+        return response.respGetData?.buf?.totalLen ?? 0;
+    }
+    /**
+     * Fragment bytes carried by the response.
+     *
+     * @param response - Parsed response.
+     */
+    static getPayload(response) {
+        return response.respGetData?.buf?.payload ?? new Uint8Array(0);
+    }
+    // Private helper methods
+    static concat(parts) {
+        const totalLength = parts.reduce((sum, part) => sum + part.length, 0);
+        const result = new Uint8Array(totalLength);
+        let pos = 0;
+        for (const part of parts) {
+            result.set(part, pos);
+            pos += part.length;
+        }
+        return result;
+    }
+    static encodeVarint(value) {
+        const bytes = [];
+        let remaining = value;
+        while (remaining > 127) {
+            bytes.push((remaining & 0x7f) | 0x80);
+            remaining >>>= 7;
+        }
+        bytes.push(remaining & 0x7f);
+        return new Uint8Array(bytes);
+    }
+    static readVarint(data, index) {
+        let value = 0;
+        let shift = 0;
+        let byte;
+        do {
+            byte = data[index++];
+            value |= (byte & 0x7f) << shift;
+            shift += 7;
+        } while (byte & 0x80);
+        return { value, newIndex: index };
+    }
+    /** Advances past a field this codec does not read. */
+    static skipField(data, index, wireType) {
+        if (wireType === WIRE_TYPE_VARINT) {
+            return this.readVarint(data, index).newIndex;
+        }
+        if (wireType === WIRE_TYPE_BYTES) {
+            const { value: length, newIndex } = this.readVarint(data, index);
+            return newIndex + length;
+        }
+        return index + 1;
+    }
+    static parseRespGetData(data) {
+        // In proto3 an absent status defaults to 0, i.e. Success.
+        const result = { status: exports.RMakerLocalCtrlStatus.Success };
+        let index = 0;
+        while (index < data.length) {
+            const tag = data[index++];
+            const fieldNumber = tag >> 3;
+            const wireType = tag & 0x07;
+            if (fieldNumber === 1 && wireType === WIRE_TYPE_VARINT) {
+                const { value, newIndex } = this.readVarint(data, index);
+                result.status = value;
+                index = newIndex;
+                continue;
+            }
+            if (fieldNumber === 2 && wireType === WIRE_TYPE_BYTES) {
+                const { value: length, newIndex } = this.readVarint(data, index);
+                result.buf = this.parsePayloadBuf(data.slice(newIndex, newIndex + length));
+                index = newIndex + length;
+                continue;
+            }
+            index = this.skipField(data, index, wireType);
+        }
+        return result;
+    }
+    static parsePayloadBuf(data) {
+        const result = {
+            offset: 0,
+            payload: new Uint8Array(0),
+            totalLen: 0,
+        };
+        let index = 0;
+        while (index < data.length) {
+            const tag = data[index++];
+            const fieldNumber = tag >> 3;
+            const wireType = tag & 0x07;
+            if (fieldNumber === 1 && wireType === WIRE_TYPE_VARINT) {
+                const { value, newIndex } = this.readVarint(data, index);
+                result.offset = value;
+                index = newIndex;
+                continue;
+            }
+            if (fieldNumber === 2 && wireType === WIRE_TYPE_BYTES) {
+                const { value: length, newIndex } = this.readVarint(data, index);
+                result.payload = data.slice(newIndex, newIndex + length);
+                index = newIndex + length;
+                continue;
+            }
+            if (fieldNumber === 3 && wireType === WIRE_TYPE_VARINT) {
+                const { value, newIndex } = this.readVarint(data, index);
+                result.totalLen = value;
+                index = newIndex;
+                continue;
+            }
+            index = this.skipField(data, index, wireType);
+        }
+        return result;
+    }
+}
+
+exports.RMakerLocalCtrlProtoHelper = RMakerLocalCtrlProtoHelper;
+//# sourceMappingURL=rmaker_local_ctrl.js.map

package/dist/cjs/proto/rmaker_local_ctrl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rmaker_local_ctrl.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/services/ESPTransport/ESPDiscovery/ESPDiscoveryManager.js

@@ -14,9 +14,10 @@ var constants = require('../../../utils/constants.js');
  * adapter (see {@link ESPRMNeoBase.setLocalDiscoveryAdapter}).
  *
  * - With no discovery config, the default local protocol is used
- *   (mDNS service `_esp_local_ctrl._tcp.` in the `local` domain).
- * - A custom {@link DiscoveryParamsInterface} can be supplied for other
- *   discovery protocols.
+ *   (mDNS service `_esp_rmaker_ctrl._tcp.` in the `local` domain — the
+ *   service advertised by RainMaker Neo firmware).
+ * - A custom {@link DiscoveryParamsInterface} can be supplied to browse any
+ *   other service type.
  */
 class ESPDiscoveryManager {
     /** Discovery parameters (service type / domain) passed to the adapter. */
@@ -31,7 +32,7 @@ class ESPDiscoveryManager {
             throw new Error("ESPLocalDiscoveryAdapter not set");
         }
         this.params = discoveryConfig || {
-            serviceType: constants.ServiceType.ESP_LOCAL_CTRL_TCP,
+            serviceType: constants.ServiceType.ESP_RMAKER_LOCAL_CTRL_TCP,
             domain: discovery.ESPDiscoveryProtocol.local,
         };
     }

package/dist/cjs/services/ESPTransport/ESPDiscovery/ESPDiscoveryManager.js.map

@@ -1 +1 @@
-{"version":3,"file":"ESPDiscoveryManager.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"ESPDiscoveryManager.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}