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

package/dist/esm/services/ESPTransport/ESPLocalControlTransport.js.map

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

package/dist/esm/services/ESPTransport/LocalControlSession.js

@@ -0,0 +1,59 @@
+import { ESPRMNeoBase } from '../../ESPRMNeoBase.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Attempts made before a local-control handshake is reported as failed. */
+const DEFAULT_CONNECT_RETRIES = 3;
+/**
+ * Returns the app-supplied local control adapter.
+ *
+ * @throws {Error} When no adapter was registered on {@link ESPRMNeoBase}.
+ */
+function getLocalControlAdapter() {
+    const adapter = ESPRMNeoBase.getLocalControlAdapter();
+    if (!adapter) {
+        throw new Error("Local control adapter is not configured");
+    }
+    return adapter;
+}
+/**
+ * Ensures a usable local-control session for `nodeId`, connecting (with
+ * retries) when the adapter reports none.
+ *
+ * The adapter resolves on a successful handshake and rejects otherwise, so a
+ * resolved `connect` is treated as connected.
+ *
+ * @param adapter - Adapter to drive.
+ * @param nodeId - Node to connect to.
+ * @param metadata - Local transport metadata (`baseUrl`, `securityType`, `pop`,
+ *   `username`).
+ * @param options - Session endpoints for the protocol in use; omitted for the
+ *   adapter's built-in default paths.
+ * @param maxRetries - Connection attempts before failing.
+ * @throws {Error} When every connection attempt fails.
+ */
+async function ensureLocalControlSession(adapter, nodeId, metadata, options, maxRetries = DEFAULT_CONNECT_RETRIES) {
+    if (await adapter.isConnected(nodeId)) {
+        return;
+    }
+    let attempt = 0;
+    let lastError;
+    while (attempt < maxRetries) {
+        try {
+            await adapter.connect(nodeId, metadata.baseUrl, metadata.securityType ?? 0, metadata.pop, metadata.username, options);
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            attempt += 1;
+        }
+    }
+    const message = lastError instanceof Error ? lastError.message : String(lastError);
+    throw new Error(`Failed to connect after ${maxRetries} attempts: ${message}`);
+}
+
+export { ensureLocalControlSession, getLocalControlAdapter };
+//# sourceMappingURL=LocalControlSession.js.map

package/dist/esm/services/ESPTransport/LocalControlSession.js.map

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

package/dist/esm/types/transport.js

@@ -17,6 +17,29 @@ var ESPTransportMode;
     /** Communication is routed through MQTT (RainMaker Neo cloud: AWS shadow). */
     ESPTransportMode["mqtt"] = "mqtt";
 })(ESPTransportMode || (ESPTransportMode = {}));
+/**
+ * Wire protocol spoken by the `local` transport. Both protocols run over a
+ * protocomm session on the node's LAN HTTP server; they differ in endpoint
+ * names and message encoding.
+ *
+ * Carried on the local transport config's `metadata.protocol`, set by local
+ * discovery from the mDNS service type that produced the hit.
+ */
+var ESPLocalControlProtocol;
+(function (ESPLocalControlProtocol) {
+    /**
+     * RainMaker Neo protocol (`rmaker_local_ctrl/*` session plus
+     * `get_params`/`set_params`/`get_config`), advertised as
+     * `_esp_rmaker_ctrl._tcp`. Default for this SDK.
+     */
+    ESPLocalControlProtocol["rmakerLocalCtrl"] = "rmaker_local_ctrl";
+})(ESPLocalControlProtocol || (ESPLocalControlProtocol = {}));
+/**
+ * Protocol assumed when a local transport config carries no explicit
+ * `metadata.protocol` — for example a LAN transport restored from a client-side
+ * registry rather than a fresh discovery hit.
+ */
+const DEFAULT_LOCAL_CONTROL_PROTOCOL = ESPLocalControlProtocol.rmakerLocalCtrl;
 /**
  * Default transport priority order used when neither the node nor the SDK base
  * has an explicit order configured: local control first, MQTT (cloud) fallback.
@@ -26,5 +49,5 @@ const DEFAULT_TRANSPORT_ORDER = [
     ESPTransportMode.mqtt,
 ];
 
-export { DEFAULT_TRANSPORT_ORDER, ESPTransportMode };
+export { DEFAULT_LOCAL_CONTROL_PROTOCOL, DEFAULT_TRANSPORT_ORDER, ESPLocalControlProtocol, ESPTransportMode };
 //# sourceMappingURL=transport.js.map

package/dist/esm/types/transport.js.map

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

package/dist/esm/utils/constants.js

@@ -473,8 +473,6 @@ const ProvisionType = {
  * An object containing endpoint paths.
  */
 const Endpoint = {
-    /** The endpoint for local control. */
-    LOCAL_CTRL: "esp_local_ctrl/control",
     /** The endpoint for cloud user association. */
     CLOUD_USER_ASSOCIATION: "cloud_user_assoc",
     /** The endpoint for challenge-response and get-node-id protocol with the device. */
@@ -482,6 +480,64 @@ const Endpoint = {
     /** The endpoint for assisted claiming. */
     RM_CLAIM: "rmaker_claim",
 };
+/**
+ * Endpoint paths of the `rmaker_local_ctrl` protocol served by RainMaker Neo
+ * firmware (see the firmware's local-control endpoint protocol spec).
+ *
+ * All data endpoints inherit the security of the session established on
+ * {@link RMakerLocalCtrlEndpoint.SESSION}.
+ */
+const RMakerLocalCtrlEndpoint = {
+    /** Protocomm session-security endpoint (SEC1 with/without PoP, or SEC2). */
+    SESSION: "rmaker_local_ctrl/session",
+    /** POST any payload; responds with the service info JSON (`sec_ver`, `cap`, …). */
+    VERSION: "rmaker_local_ctrl/version",
+    /** Reads the params JSON — protobuf `CmdGetData`, fragmented response. */
+    GET_PARAMS: "get_params",
+    /** Reads the node config JSON — protobuf `CmdGetData`, fragmented response. */
+    GET_CONFIG: "get_config",
+    /** Writes params — raw JSON request and response (no protobuf). */
+    SET_PARAMS: "set_params",
+};
+/**
+ * Root key of the JSON served by {@link RMakerLocalCtrlEndpoint.VERSION}, i.e.
+ * `{"rmaker_local_ctrl": {"ver": …, "sec_ver": …, "cap": [...]}}`. Passed to the
+ * local-control adapter so the native layer probes the right scheme version.
+ */
+const RMAKER_LOCAL_CTRL_VERSION_KEY = "rmaker_local_ctrl";
+/**
+ * Maximum fragment size (bytes) the firmware serves per `RespGetData`. Reads
+ * loop with `Offset += Payload.length` until `TotalLen` is reached; this value
+ * is informational (the device dictates the actual fragment length).
+ */
+const RMAKER_LOCAL_CTRL_FRAGMENT_SIZE = 200;
+/**
+ * `status` values in a `set_params` raw-JSON response.
+ */
+const RMakerLocalCtrlSetParamsStatus = {
+    SUCCESS: "success",
+    FAIL: "fail",
+};
+/**
+ * mDNS TXT record keys advertised by the `_esp_rmaker_ctrl._tcp` service.
+ */
+const RMakerLocalCtrlTxtKey = {
+    /** Node ID (also the service instance name and hostname). */
+    NODE_ID: "node_id",
+    /** Comma-separated active capabilities — see {@link RMakerLocalCtrlCapability}. */
+    CAP: "cap",
+};
+/**
+ * Capability tokens found in the `cap` TXT record. A node advertising only
+ * `ch_resp` is reachable for on-network user-node association but *not* for
+ * param control, so it must not be registered as a local control transport.
+ */
+const RMakerLocalCtrlCapability = {
+    /** Params/config endpoints are registered. */
+    LOCAL_CTRL: "local_ctrl",
+    /** Challenge-response (on-network user-node association) is registered. */
+    CH_RESP: "ch_resp",
+};
 /**
  * Assisted-claiming REST paths, on the deployment's main API and SigV4-signed
  * like every other `/v1/*` route.
@@ -639,8 +695,12 @@ const ProvErrorCodes = {
  * @enum {string}
  */
 const ServiceType = {
-    /** Represents the ESP local control TCP service type. */
-    ESP_LOCAL_CTRL_TCP: "_esp_local_ctrl._tcp.",
+    /**
+     * Service type advertised by RainMaker Neo firmware. A single instance serves
+     * the `rmaker_local_ctrl` endpoints; the `cap` TXT record says which endpoint
+     * sets are active. This is the default for local discovery in this SDK.
+     */
+    ESP_RMAKER_LOCAL_CTRL_TCP: "_esp_rmaker_ctrl._tcp.",
 };
 /**
  * An object containing protocol types.
@@ -849,5 +909,5 @@ const SubscriptionChannelIds = {
     MQTT: "mqtt",
 };
 
-export { APICallValidationErrorCodes, APIEndpoints, APIOperations, APIPathV1, AWSCredentialsErrorMessages, AssumeRoleErrorMessages, AuthErrorCodes, AuthSuccessMessages, AutomationStatusValues, AutomationSuccessMessages, CLAIM_CSR_MAX_CHUNKS, CLAIM_DEVICE_CSR_KEYS, CLAIM_DEVICE_MAC_KEYS, CLAIM_MAC_HEX_LENGTHS, CLAIM_MAC_SEPARATORS, CLAIM_MAX_FRAGMENT_SIZE, ClaimCapabilities, ClaimCapabilityPolicies, ClaimEndpoints, ClaimErrorCodes, ClaimProgressMessages, ConfigErrorCodes, DEFAULT_REST_API_VERSION, ESPProvProgressMessages, ESPRMNeoErrorCodes, ESPRMNeoStorageKeys, ESPServiceParamType, ESPServiceType, Endpoint, ErrorLabels, GroupSuccessMessages, GroupUserAliases, HTTPMethods, IntegrationSuccessMessages, NodeSuccessMessages, NodeWarnMessages, ProtocolType, ProvErrorCodes, ProvisionType, SDK_VERSION, ScheduleErrorMessages, ScheduleSuccessMessages, ServiceType, SharingSuccessMessages, StatusMessage, StorageAdapterErrorCodes, StorageKeys, SubscriptionChannelIds, TokenErrorCodes, TriggerErrorMessages, TriggerSuccessMessages, ValidationErrorCodes };
+export { APICallValidationErrorCodes, APIEndpoints, APIOperations, APIPathV1, AWSCredentialsErrorMessages, AssumeRoleErrorMessages, AuthErrorCodes, AuthSuccessMessages, AutomationStatusValues, AutomationSuccessMessages, CLAIM_CSR_MAX_CHUNKS, CLAIM_DEVICE_CSR_KEYS, CLAIM_DEVICE_MAC_KEYS, CLAIM_MAC_HEX_LENGTHS, CLAIM_MAC_SEPARATORS, CLAIM_MAX_FRAGMENT_SIZE, ClaimCapabilities, ClaimCapabilityPolicies, ClaimEndpoints, ClaimErrorCodes, ClaimProgressMessages, ConfigErrorCodes, DEFAULT_REST_API_VERSION, ESPProvProgressMessages, ESPRMNeoErrorCodes, ESPRMNeoStorageKeys, ESPServiceParamType, ESPServiceType, Endpoint, ErrorLabels, GroupSuccessMessages, GroupUserAliases, HTTPMethods, IntegrationSuccessMessages, NodeSuccessMessages, NodeWarnMessages, ProtocolType, ProvErrorCodes, ProvisionType, RMAKER_LOCAL_CTRL_FRAGMENT_SIZE, RMAKER_LOCAL_CTRL_VERSION_KEY, RMakerLocalCtrlCapability, RMakerLocalCtrlEndpoint, RMakerLocalCtrlSetParamsStatus, RMakerLocalCtrlTxtKey, SDK_VERSION, ScheduleErrorMessages, ScheduleSuccessMessages, ServiceType, SharingSuccessMessages, StatusMessage, StorageAdapterErrorCodes, StorageKeys, SubscriptionChannelIds, TokenErrorCodes, TriggerErrorMessages, TriggerSuccessMessages, ValidationErrorCodes };
 //# sourceMappingURL=constants.js.map

package/dist/esm/utils/constants.js.map

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

package/dist/esm/utils/eventSubscriptionUtils.js

@@ -1,26 +1,70 @@
 import { ESPDiscoveryManager } from '../services/ESPTransport/ESPDiscovery/ESPDiscoveryManager.js';
 import { subscribeNodeUpdates } from '../services/NodeUpdatesBus.js';
-import { ESPTransportMode } from '../types/transport.js';
+import { ESPLocalControlProtocol, ESPTransportMode } from '../types/transport.js';
+import { RMakerLocalCtrlCapability, RMakerLocalCtrlTxtKey } from './constants.js';
 
 /*
  * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-/** Maps a default local-discovery hit into the client-facing payload shape. */
+/**
+ * Splits the mDNS `cap` TXT record (`"local_ctrl,ch_resp"`) into tokens.
+ * Returns `undefined` when the record is absent, which older firmware omits.
+ */
+function parseCapabilities(txt) {
+    const raw = txt?.[RMakerLocalCtrlTxtKey.CAP];
+    if (typeof raw !== "string")
+        return undefined;
+    const capabilities = raw
+        .split(",")
+        .map((capability) => capability.trim())
+        .filter(Boolean);
+    return capabilities.length ? capabilities : undefined;
+}
+/**
+ * Maps a default local-discovery hit into the client-facing payload shape.
+ *
+ * The `_esp_rmaker_ctrl._tcp` instance is also advertised by nodes that
+ * only serve challenge-response (on-network user-node association). Those are
+ * not reachable for param control, so a hit whose `cap` TXT record excludes
+ * `local_ctrl` maps to `undefined` and is dropped rather than registered as a
+ * local transport. A hit with no `cap` record is treated as control-capable.
+ *
+ * @param info - Raw adapter result (`nodeId`, `baseUrl`, and `txt` when the
+ *   platform resolved TXT records).
+ * @returns The payload to deliver, or `undefined` to skip this hit.
+ */
 function toDiscoveredNodeData(info) {
+    const capabilities = parseCapabilities(info.txt);
+    if (capabilities &&
+        !capabilities.includes(RMakerLocalCtrlCapability.LOCAL_CTRL)) {
+        return undefined;
+    }
     return {
         nodeId: info.nodeId,
         transportDetails: {
             type: ESPTransportMode.local,
-            metadata: { baseUrl: info.baseUrl },
+            metadata: {
+                baseUrl: info.baseUrl,
+                protocol: ESPLocalControlProtocol.rmakerLocalCtrl,
+                ...(capabilities && { capabilities }),
+            },
         },
     };
 }
-/** Starts LAN discovery; each hit is mapped then passed to `onDiscovered`. */
+/**
+ * Starts LAN discovery; each hit is mapped then passed to `onDiscovered`.
+ * Hits that are not control-capable (see {@link toDiscoveredNodeData}) are
+ * skipped.
+ */
 function startLocalDiscovery(onDiscovered) {
     const manager = new ESPDiscoveryManager();
-    manager.startDiscovery((info) => onDiscovered(toDiscoveredNodeData(info)));
+    manager.startDiscovery((info) => {
+        const data = toDiscoveredNodeData(info);
+        if (data)
+            onDiscovered(data);
+    });
     return { stop: () => manager.stopDiscovery() };
 }
 /** Forwards process-wide node param updates to `onUpdate`. */

package/dist/esm/utils/eventSubscriptionUtils.js.map

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

package/dist/types/ESPRMNeoBase.d.ts

@@ -115,7 +115,7 @@ export declare class ESPRMNeoBase {
     static getProvisionAdapter(): ESPProvisionAdapterInterface | undefined;
     /**
      * 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/types/proto/rmaker_local_ctrl.d.ts

@@ -0,0 +1,137 @@
+/**
+ * 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.
+ */
+export declare enum RMakerLocalCtrlStatus {
+    Success = 0,
+    Fail = 1,
+    InvalidParam = 2,
+    NoMemory = 3
+}
+/**
+ * Selects which document a read targets.
+ */
+export declare enum RMakerLocalCtrlDataType {
+    /** The node's params JSON, as served by `get_params`. */
+    TypeParams = 0,
+    /** The node's config JSON, as served by `get_config`. */
+    TypeConfig = 1
+}
+/**
+ * Message type discriminator carried on `RMakerLocalCtrlPayload.msg`.
+ */
+export declare enum RMakerLocalCtrlMsgType {
+    TypeCmdGetData = 0,
+    TypeRespGetData = 1
+}
+/**
+ * One fragment of a larger document.
+ */
+export interface PayloadBuf {
+    /** Byte offset of this fragment within the document. */
+    offset: number;
+    /** Fragment bytes (up to 200 per response). */
+    payload: Uint8Array;
+    /** Full document length in bytes. */
+    totalLen: number;
+}
+/**
+ * Device response to a data read.
+ */
+export interface RespGetData {
+    /** Read status. */
+    status: RMakerLocalCtrlStatus;
+    /** Fragment carried by this response. */
+    buf?: PayloadBuf;
+}
+/**
+ * Envelope exchanged on the `get_params` / `get_config` endpoints.
+ */
+export interface RMakerLocalCtrlPayload {
+    /** Message type. */
+    msg: RMakerLocalCtrlMsgType;
+    /** Response payload (device → app). */
+    respGetData?: RespGetData;
+}
+/**
+ * Encoder/decoder for `rmaker_local_ctrl` frames.
+ */
+export declare 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: RMakerLocalCtrlDataType, offset: number): Uint8Array;
+    /**
+     * 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: Uint8Array): RMakerLocalCtrlPayload;
+    /**
+     * Whether the device reported a successful read.
+     *
+     * @param response - Parsed response.
+     */
+    static isSuccess(response: RMakerLocalCtrlPayload): boolean;
+    /**
+     * 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: RMakerLocalCtrlPayload): string;
+    /**
+     * Offset the device answered with, which must match the requested offset.
+     *
+     * @param response - Parsed response.
+     */
+    static getOffset(response: RMakerLocalCtrlPayload): number;
+    /**
+     * Full document length reported by the device.
+     *
+     * @param response - Parsed response.
+     */
+    static getTotalLen(response: RMakerLocalCtrlPayload): number;
+    /**
+     * Fragment bytes carried by the response.
+     *
+     * @param response - Parsed response.
+     */
+    static getPayload(response: RMakerLocalCtrlPayload): Uint8Array;
+    private static concat;
+    private static encodeVarint;
+    private static readVarint;
+    /** Advances past a field this codec does not read. */
+    private static skipField;
+    private static parseRespGetData;
+    private static parsePayloadBuf;
+}

package/dist/types/services/ESPTransport/ESPDiscovery/ESPDiscoveryManager.d.ts

@@ -4,9 +4,10 @@ import { DiscoveryParamsInterface, ESPDiscoveryCallback } from "../../../types/d
  * 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.
  */
 declare class ESPDiscoveryManager {
     /** Discovery parameters (service type / domain) passed to the adapter. */

package/dist/types/services/ESPTransport/ESPLocalControlTransport.d.ts

@@ -2,37 +2,84 @@ import type { ESPRMNeoNode } from "../../ESPRMNeoNode";
 import { ESPAPIResponse } from "../../types/output";
 import { ESPTransportConfig, ESPTransportInterface } from "../../types/transport";
 /**
- * Built-in `local` transport. Communicates with the node over the LAN through
- * the app-supplied {@link ESPRMNeoBase.ESPLocalControlAdapter} using the
- * `esp_local_ctrl` protobuf protocol. Connection metadata (`baseUrl`,
- * `securityType`, `pop`, and `username` for sec2) is supplied via the transport
- * config by {@link delegatedTransportHandler}.
+ * The built-in `local` transport, speaking the `rmaker_local_ctrl` endpoint
+ * protocol over the app-supplied {@link ESPRMNeoBase.ESPLocalControlAdapter}:
+ *
+ * - `set_params` carries the same raw JSON body as a cloud set-params call and
+ *   answers `{"status":"success"}` / `{"status":"fail","description":…}`.
+ * - `get_params` / `get_config` exchange protobuf `CmdGetData`/`RespGetData` and
+ *   are fragmented — the client pulls fixed-size chunks by offset until
+ *   `TotalLen` is covered.
+ *
+ * Connection metadata (`baseUrl`, `securityType`, `pop`, and `username` for
+ * sec2) is supplied via the transport config by {@link
+ * delegatedTransportHandler}; security 0 is not offered by this protocol.
  */
 declare class ESPLocalControlTransport implements ESPTransportInterface {
-    private payload;
     metadata: Record<string, any>;
-    propertyInfo: Record<string, any>;
     constructor(transportConfig: ESPTransportConfig);
     private get adapter();
+    private ensureConnected;
     /**
-     * Connects to the node, retrying on failure. RMNeo's adapter resolves on a
-     * successful connection and rejects otherwise, so a resolved call is treated
-     * as connected.
+     * Applies params over `set_params`.
+     *
+     * @param payload - `{ node_id, payload }`, where `payload` is the
+     *   `{ <deviceOrServiceName>: { <paramName>: value } }` map to write.
+     * @throws {Error} When the device reports a non-success status.
      */
-    private connectWithRetry;
-    private ensureConnected;
     setParam(payload: Record<string, any>, _nodeRef?: ESPRMNeoNode): Promise<ESPAPIResponse>;
+    /**
+     * Reads the node's full params document over `get_params`.
+     *
+     * @param payload - `{ node_id }` identifying the node to read.
+     * @returns The params JSON, keyed by device/service name.
+     */
     getParams(payload: Record<string, any>, _nodeRef?: ESPRMNeoNode): Promise<Record<string, any>>;
-    private setProperty;
-    private buildSetPropertyRequest;
-    private processSetPropertyResponse;
-    /** Fetches the property count, then reads each property value into propertyInfo. */
-    private getPropertyInfo;
-    private fetchPropertyCount;
-    private buildGetPropertyCountRequest;
-    private processGetPropertyCountResponse;
-    private fetchPropertyValue;
-    private buildGetPropertyValueRequest;
-    private processGetPropertyValueResponse;
+    /**
+     * Reads the node's config document over `get_config`. Not part of
+     * {@link ESPTransportInterface} — the node config normally comes from the
+     * cloud; this serves LAN-only flows.
+     *
+     * @param nodeId - Node to read from.
+     * @returns The node config JSON.
+     */
+    getConfig(nodeId: string): Promise<Record<string, any>>;
+    /**
+     * Validates a `set_params` raw-JSON response.
+     *
+     * @throws {Error} When the body is unparseable or reports a failure.
+     */
+    private assertSetParamsAccepted;
+    /**
+     * Pulls a fragmented document and parses it as JSON, serialized against every
+     * other fragmented read of the same node.
+     *
+     * The device holds **one global transfer cache**, not one per session: an
+     * offset-0 request regenerates it and it is freed after the last fragment. So
+     * a `getParams()` racing a `getConfig()` on the same node would clobber the
+     * other — the second offset-0 regenerates the cache mid-transfer, and the
+     * first read's next fragment comes back `Fail` (or, worse, carries bytes from
+     * the wrong document). The queue makes that interleaving impossible rather
+     * than detecting it after the fact.
+     *
+     * @param nodeId - Node to read from.
+     * @param dataType - Which document to read (params or config).
+     * @param endpoint - Endpoint serving that document.
+     * @throws {Error} When the device reports a failure, the response is
+     *   malformed, or a fragment makes no forward progress.
+     */
+    private readJsonDocument;
+    /** The client-pull loop itself; always reached via {@link readJsonDocument}. */
+    private pullJsonDocument;
+    private buildGetDataRequest;
+    /**
+     * Parses one `RespGetData` and checks it answers the requested offset.
+     *
+     * @param response - Base64 protobuf response from the adapter.
+     * @param requestedOffset - Offset asked for, used to detect a desynced pull.
+     */
+    private processGetDataResponse;
+    /** Joins the pulled fragments and parses the result as JSON. */
+    private parseJsonFragments;
 }
 export { ESPLocalControlTransport };

package/dist/types/services/ESPTransport/LocalControlSession.d.ts

@@ -0,0 +1,24 @@
+import type { ESPLocalControlAdapterInterface, ESPLocalControlSessionOptions } from "../../types/localControl";
+/**
+ * Returns the app-supplied local control adapter.
+ *
+ * @throws {Error} When no adapter was registered on {@link ESPRMNeoBase}.
+ */
+export declare function getLocalControlAdapter(): ESPLocalControlAdapterInterface;
+/**
+ * Ensures a usable local-control session for `nodeId`, connecting (with
+ * retries) when the adapter reports none.
+ *
+ * The adapter resolves on a successful handshake and rejects otherwise, so a
+ * resolved `connect` is treated as connected.
+ *
+ * @param adapter - Adapter to drive.
+ * @param nodeId - Node to connect to.
+ * @param metadata - Local transport metadata (`baseUrl`, `securityType`, `pop`,
+ *   `username`).
+ * @param options - Session endpoints for the protocol in use; omitted for the
+ *   adapter's built-in default paths.
+ * @param maxRetries - Connection attempts before failing.
+ * @throws {Error} When every connection attempt fails.
+ */
+export declare function ensureLocalControlSession(adapter: ESPLocalControlAdapterInterface, nodeId: string, metadata: Record<string, any>, options?: ESPLocalControlSessionOptions, maxRetries?: number): Promise<void>;

package/dist/types/types/discovery.d.ts

@@ -23,7 +23,7 @@ declare enum ESPRMNeoEventType {
  * (e.g. mDNS service type and domain).
  */
 interface DiscoveryParamsInterface {
-    /** Service type to browse for, e.g. `_esp_local_ctrl._tcp.` */
+    /** Service type to browse for, e.g. `_esp_rmaker_ctrl._tcp.` */
     serviceType: string;
     /** Discovery domain, e.g. `local`. */
     domain: string;

package/dist/types/types/localControl.d.ts

@@ -1,3 +1,25 @@
+/**
+ * Per-connection session details passed to {@link
+ * ESPLocalControlAdapterInterface.connect}. The protocomm handshake endpoint
+ * differs per local-control protocol, so the transport tells the native layer
+ * which paths to use instead of the adapter hardcoding them.
+ *
+ * Adapters built against an earlier SDK simply ignore the extra argument and
+ * keep using their built-in default paths.
+ */
+export interface ESPLocalControlSessionOptions {
+    /** Protocol tag, one of {@link ESPLocalControlProtocol}. */
+    protocol: string;
+    /** Protocomm session-security endpoint, e.g. `rmaker_local_ctrl/session`. */
+    sessionPath: string;
+    /** Version/service-info endpoint, e.g. `rmaker_local_ctrl/version`. */
+    versionPath: string;
+    /**
+     * Root key to read in the version response when probing the security scheme
+     * version, e.g. `rmaker_local_ctrl` for `{"rmaker_local_ctrl": {…}}`.
+     */
+    versionKey: string;
+}
 /**
  * Local control adapter interface for node communication over LAN.
  */
@@ -8,8 +30,11 @@ export interface ESPLocalControlAdapterInterface {
     isConnected(nodeId: string): Promise<boolean>;
     /**
      * Connects to the node with local control parameters.
+     *
+     * @param options - Session endpoints for the protocol in use. Omitted only by
+     *   callers that want the adapter's built-in default paths.
      */
-    connect(nodeId: string, baseUrl: string, securtiyType: number, pop?: string, username?: string): Promise<Record<string, unknown>>;
+    connect(nodeId: string, baseUrl: string, securtiyType: number, pop?: string, username?: string, options?: ESPLocalControlSessionOptions): Promise<Record<string, unknown>>;
     /**
      * Sends data to the specified path on the node.
      */