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

package/dist/esm/ESPRMNeoNode.js

@@ -38,14 +38,19 @@ class ESPRMNeoNode {
     subgroupIds = [];
     devices = [];
     services = [];
+    /**
+     * Last-known connectivity. Seeded from cached `connectivity_status` when
+     * present (cloud config does not provide it); otherwise starts offline until
+     * an MQTT shadow `online` update arrives.
+     */
     connectivityStatus = {
         isConnected: false,
         lastConnectionTimestamp: 0,
     };
     /**
      * Transports currently usable for this node, keyed by mode.
-     * - `mqtt` (cloud) is added when the node reports online and removed when
-     *   it goes offline (via shadow updates or seeded `connectivity_status`).
+     * - `mqtt` (cloud) is added when the node is connected and removed when it
+     *   goes offline (from cached `connectivity_status` or shadow updates).
      * - `local` is added/removed at runtime by a `localDiscovery` subscriber as the
      *   node appears/disappears on the LAN (via {@link addTransport}/{@link removeTransport}).
      * Apps may also add custom string-keyed entries (pair with
@@ -78,16 +83,11 @@ class ESPRMNeoNode {
         this.subgroupIds = asStringArray(subgroupIdOrIds);
         this.transportOrder = ESPRMNeoBase.getTransportOrder();
         this.availableTransports = {};
-        this.applyNodeConfig(config);
         if (config.connectivity_status) {
             this.connectivityStatus = config.connectivity_status;
         }
-        if (this.connectivityStatus.isConnected) {
-            this.addTransport(ESPTransportMode.mqtt, {
-                type: ESPTransportMode.mqtt,
-                metadata: {},
-            });
-        }
+        this.applyNodeConfig(config);
+        this.syncMqttTransportAvailability();
         this.subscribeToMqttUpdates();
     }
     /**
@@ -167,11 +167,14 @@ class ESPRMNeoNode {
         this.devices = deviceRecords.map((d) => new ESPRMNeoDevice(transformNodeDevice(d), nodeRef));
         this.services = serviceRecords.map((s) => new ESPRMNeoService(transformNodeService(s), nodeRef));
         // Keep wire records for cache writes (never persist live class instances).
+        // Preserve last-known connectivity when the incoming config omits it
+        // (cloud node config does not include connectivity_status).
         this.wireConfig = {
             ...config,
             info,
             devices: deviceRecords,
             services: serviceRecords,
+            connectivity_status: config.connectivity_status ?? this.connectivityStatus,
         };
         this.config = {
             ...config,
@@ -241,19 +244,27 @@ class ESPRMNeoNode {
             this.wireConfig.params = this.config.params;
         }
         this.applyConnectivityStatus(shadow, connectivityStatus);
-        ESPRMNeoStorage.setItem(StorageKeys.NODE_CONFIG_PREFIX + this.nodeId, JSON.stringify({ ...this.wireConfig, node_id: this.nodeId }));
+        this.persistWireConfig();
         this.refreshConfigIfNcfgChanged(shadow);
     }
     /**
-     * Updates {@link connectivityStatus} and MQTT transport availability when the
-     * shadow reports `online`. Partial updates without `online` are ignored so
-     * an existing status is not cleared.
+     * Updates {@link connectivityStatus} when the shadow reports `online`, then
+     * syncs MQTT transport availability. Partial updates without `online` are
+     * ignored so an existing status is not cleared.
      */
     applyConnectivityStatus(shadow, connectivityStatus) {
         if (shadow.state?.reported?.online === undefined)
             return;
         this.connectivityStatus = connectivityStatus;
-        if (connectivityStatus.isConnected) {
+        this.wireConfig.connectivity_status = connectivityStatus;
+        this.syncMqttTransportAvailability();
+    }
+    /**
+     * Registers the MQTT transport only while {@link connectivityStatus} reports
+     * the node as connected; removes it when offline.
+     */
+    syncMqttTransportAvailability() {
+        if (this.connectivityStatus.isConnected) {
             this.addTransport(ESPTransportMode.mqtt, {
                 type: ESPTransportMode.mqtt,
                 metadata: {},
@@ -263,6 +274,14 @@ class ESPRMNeoNode {
             this.removeTransport(ESPTransportMode.mqtt);
         }
     }
+    /** Persists {@link wireConfig} (including last-known connectivity) to storage. */
+    persistWireConfig() {
+        ESPRMNeoStorage.setItem(StorageKeys.NODE_CONFIG_PREFIX + this.nodeId, JSON.stringify({
+            ...this.wireConfig,
+            node_id: this.nodeId,
+            connectivity_status: this.connectivityStatus,
+        }));
+    }
     /** When cloud `ncfg_ver` changes, refetch config and persist the new marker. */
     async refreshConfigIfNcfgChanged(shadow) {
         try {

package/dist/esm/ESPRMNeoNode.js.map

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

package/dist/esm/index.js

@@ -102,6 +102,8 @@ import './methods/ESPDevice/SetProofOfPossession.js';
 import './methods/ESPDevice/SendData.js';
 import './methods/ESPDevice/InitializeSession.js';
 import './methods/ESPDevice/SetNetworkCredentials.js';
+import './methods/ESPDevice/ResetWifiStatus.js';
+import './methods/ESPDevice/RetryNetworkCredentials.js';
 import './methods/ESPDevice/InitiateUserNodeMapping.js';
 import './methods/ESPDevice/VerifyUserNodeMapping.js';
 import './methods/ESPDevice/StartAssistedClaiming.js';
@@ -109,7 +111,7 @@ export { buildGroupControlParamsTopic, buildRainMakerUserParamsTopic, buildShado
 export { coerceToFiniteNumber, coerceToNonEmptyString, coerceToString } from './utils/coerce.js';
 export { buildCanonicalQueryString, createAuthorizationHeader, generateIotDeviceGatewayMqttSignedUrl, generateSigV4AuthHeader } from './utils/awsSigv4Utils.js';
 export { buildMainApiUrl, buildUserCredentialsUrl, ensureValidIdToken, extractTemporaryCredentials, isExpiredTokenAuthError, parseCredentialsErrorMessage, postUserCredentials, refreshUserSession } from './utils/awsUtils.js';
-export { APICallValidationErrorCodes, APIEndpoints, APIOperations, APIPathV1, AWSCredentialsErrorMessages, 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 } from './utils/constants.js';
+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 } from './utils/constants.js';
 export { LogLevel, Logger } from './utils/logger.js';
 export { concurrentFetchPool } from './utils/mapLimit.js';
 export { EventEmitter } from './utils/eventEmitter.js';

package/dist/esm/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/esm/methods/ESPDevice/Provision.js

@@ -65,6 +65,13 @@ async function runChallengeResponseFlow(device, ssid, passphrase, groupId, onPro
         challenge_response: signedChallenge,
         node_id: nodeId,
     });
+    // Association is verified and cannot be repeated; remember what step 6 needs
+    // so `retryNetworkCredentials` can resume from the Wi-Fi step.
+    device.provisionResumeState = {
+        nodeId: nodeId,
+        groupId,
+        options: options,
+    };
     // 5. SET NETWORK CREDENTIALS
     reportProgress(onProgress, ESPProvResponseStatus.onProgress, ESPProvProgressMessages.SETTING_NETWORK_CREDENTIALS);
     await device.setNetworkCredentials(ssid, passphrase);

package/dist/esm/methods/ESPDevice/Provision.js.map

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

package/dist/esm/methods/ESPDevice/ResetWifiStatus.js

@@ -0,0 +1,24 @@
+import { ESPDevice } from '../../ESPDevice.js';
+import { Logger } from '../../utils/logger.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("ResetWifiStatus");
+ESPDevice.prototype.resetWifiStatus = async function () {
+    if (!this.ESPProvisionAdapter.resetWifiStatus) {
+        logger.warn(`Adapter has no resetWifiStatus; treating as not acknowledged for "${this.name}"`);
+        return false;
+    }
+    try {
+        const acknowledged = await this.ESPProvisionAdapter.resetWifiStatus(this.name);
+        return acknowledged;
+    }
+    catch (error) {
+        logger.error(`<- device "${this.name}": reset failed`, error);
+        throw error;
+    }
+};
+//# sourceMappingURL=ResetWifiStatus.js.map

package/dist/esm/methods/ESPDevice/ResetWifiStatus.js.map

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

package/dist/esm/methods/ESPDevice/RetryNetworkCredentials.js

@@ -0,0 +1,44 @@
+import { ESPDevice } from '../../ESPDevice.js';
+import { ESPProvResponseStatus } from '../../types/provision.js';
+import { ESPProvProgressMessages } from '../../utils/constants.js';
+import { ESPProvError } from '../../utils/error/ESPProvError.js';
+import { waitForNodeOnline, DEFAULT_NODE_ONLINE_TIMEOUT_MS } from '../../utils/waitForNodeOnline.js';
+import { Logger } from '../../utils/logger.js';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new Logger("RetryNetworkCredentials");
+ESPDevice.prototype.retryNetworkCredentials = async function (ssid, passphrase, onProgress) {
+    const resumeState = this.provisionResumeState;
+    if (!resumeState) {
+        logger.error(`Retry refused for "${this.name}": no association recorded, nothing to resume`);
+        throw new ESPProvError("FAILED_PROV");
+    }
+    onProgress({
+        status: ESPProvResponseStatus.onProgress,
+        description: ESPProvProgressMessages.SETTING_NETWORK_CREDENTIALS,
+    });
+    await this.setNetworkCredentials(ssid, passphrase);
+    const options = resumeState.options;
+    if (options?.waitForOnline && options.user) {
+        onProgress({
+            status: ESPProvResponseStatus.onProgress,
+            description: ESPProvProgressMessages.WAITING_FOR_ONLINE,
+        });
+        await waitForNodeOnline({
+            nodeId: resumeState.nodeId,
+            groupId: resumeState.groupId,
+            user: options.user,
+            timeoutMs: options.onlineTimeoutMs ?? DEFAULT_NODE_ONLINE_TIMEOUT_MS,
+        });
+    }
+    onProgress({
+        status: ESPProvResponseStatus.succeed,
+        description: resumeState.nodeId ?? ESPProvProgressMessages.DEVICE_PROVISIONED,
+    });
+    return resumeState.nodeId;
+};
+//# sourceMappingURL=RetryNetworkCredentials.js.map

package/dist/esm/methods/ESPDevice/RetryNetworkCredentials.js.map

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

package/dist/esm/methods/ESPRMNeoNode/Sync.js

@@ -14,7 +14,10 @@ ESPRMNeoNode.prototype.sync = async function () {
         // Apply first so a schema issue surfaces to the caller instead of
         // poisoning the storage cache for the next cold start.
         this.applyNodeConfig(config);
-        await writeLocalNodeConfig(this.nodeId, config);
+        await writeLocalNodeConfig(this.nodeId, {
+            ...config,
+            connectivity_status: this.connectivityStatus,
+        });
         return this;
     }
     catch (error) {

package/dist/esm/methods/ESPRMNeoNode/Sync.js.map

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

package/dist/esm/methods/ESPRMNeoUser/MQTT/AssumeRole.js

@@ -1,5 +1,5 @@
 import { ESPRMNeoUser } from '../../../ESPRMNeoUser.js';
-import { APIPathV1 } from '../../../utils/constants.js';
+import { AssumeRoleErrorMessages, APIPathV1 } from '../../../utils/constants.js';
 import { ESPSigV4APIManager } from '../../../services/ESPSigV4APIManager.js';
 
 /*
@@ -9,27 +9,26 @@ import { ESPSigV4APIManager } from '../../../services/ESPSigV4APIManager.js';
  */
 /**
  * Implementation of the `assumeRole` method for the `ESPRMNeoUser` class.
- *
- * Exchanges identity (temporary) credentials for assume-role credentials with IoT/MQTT
- * permissions. The backend signs the user in with the provided credentials and returns
- * a new credential set for MQTT; this is not refreshing or extending the same credentials.
  */
 ESPRMNeoUser.prototype.assumeRole = async function (accessKey, secretKey, sessionToken, options) {
-    // Request body: identity (temporary) credentials so backend can assume the IoT role
     const requestBody = {
         access_key: accessKey,
         secret_key: secretKey,
         session_token: sessionToken,
     };
-    // Merge optional fields (e.g., include: ["s3", "kvs"])
-    if (options?.include && options.include.length > 0) {
-        requestBody.include = options.include;
+    const servicesMode = !!(options?.services && options.services.length > 0);
+    if (servicesMode) {
+        if (!options.nodeId) {
+            throw new Error(AssumeRoleErrorMessages.NODE_ID_REQUIRED);
+        }
+        requestBody.services = options.services;
+        requestBody.node_id = options.nodeId;
     }
     const api = ESPSigV4APIManager.getInstance();
     const response = await api.post(APIPathV1.ASSUME_ROLE, requestBody);
     // Validate response contains required fields
     if (!response.access_key || !response.secret_key || !response.session_token) {
-        throw new Error("Invalid assume role response: missing required credential fields");
+        throw new Error(AssumeRoleErrorMessages.INVALID_RESPONSE);
     }
     return response;
 };

package/dist/esm/methods/ESPRMNeoUser/MQTT/AssumeRole.js.map

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

package/dist/esm/proto/esp_rmaker_chal_resp.js

@@ -1,5 +1,10 @@
 import * as pb_1 from 'google-protobuf';
 
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * Generated by the protoc-gen-ts.  DO NOT EDIT!
  * compiler version: 5.29.3

package/dist/esm/proto/esp_rmaker_chal_resp.js.map

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

package/dist/esm/services/ESPRMNeoMqtt/ESPRMNeoMqtt.js

@@ -85,6 +85,19 @@ class ESPRMNeoMqtt {
     isConnected() {
         return this.#adapter.isConnected();
     }
+    /**
+     * Registers a transport connection-status listener when the underlying
+     * adapter supports it; otherwise returns a no-op unsubscribe.
+     *
+     * @param callback - Invoked with `{ connected }` on status changes
+     * @returns Unsubscribe function
+     */
+    onConnectionStatusChange(callback) {
+        if (typeof this.#adapter.onConnectionStatusChange === "function") {
+            return this.#adapter.onConnectionStatusChange(callback);
+        }
+        return () => { };
+    }
     /**
      * Publish a message to a topic.
      *

package/dist/esm/services/ESPRMNeoMqtt/ESPRMNeoMqtt.js.map

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

package/dist/esm/services/NodeMQTTOrchestrator.js

@@ -139,8 +139,8 @@ class NodeMQTTOrchestrator {
     /**
      * Registers a node with the orchestrator.
      * Must be called before subscribeToNode, getParams, getShadow, etc.
-     * On shadow rename: clears the old binding; ignores shorter/incomplete names.
-     * Shrink membership via {@link unregisterNode} first.
+     * On shadow rename: clears the old binding, then installs the new name
+     * (including shrinks to a shorter membership shadow).
      *
      * @param nodeId - The device/node identifier.
      * @param shadowName - The named shadow (e.g. `params-groupId-subgroupId`).
@@ -149,9 +149,6 @@ class NodeMQTTOrchestrator {
         const instance = NodeMQTTOrchestrator.getInstance();
         const existing = instance.nodeMap.get(nodeId);
         if (existing && existing.shadowName !== shadowName) {
-            if (shadowName.split("-").length < existing.shadowName.split("-").length) {
-                return;
-            }
             NodeMQTTOrchestrator.unregisterNode(nodeId);
         }
         instance.nodeMap.set(nodeId, { shadowName });

package/dist/esm/services/NodeMQTTOrchestrator.js.map

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

package/dist/esm/utils/constants.js

@@ -391,6 +391,15 @@ const TriggerErrorMessages = {
     /** Logged when retrieving triggers for a node fails. */
     GET_FAILED: "getTriggers failed",
 };
+/**
+ * Error messages for assumeRole (POST /v1/assumed-roles).
+ */
+const AssumeRoleErrorMessages = {
+    /** Thrown when `services` is provided without a `nodeId`. */
+    NODE_ID_REQUIRED: "assumeRole: nodeId is required when services is provided",
+    /** Thrown when the assume-role response is missing required credential fields. */
+    INVALID_RESPONSE: "Invalid assume role response: missing required credential fields",
+};
 /**
  * Error / log messages for temporary AWS credentials (POST /v1/user/credentials).
  */
@@ -840,5 +849,5 @@ const SubscriptionChannelIds = {
     MQTT: "mqtt",
 };
 
-export { APICallValidationErrorCodes, APIEndpoints, APIOperations, APIPathV1, AWSCredentialsErrorMessages, 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, 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/nodeUtils.js

@@ -26,7 +26,18 @@ async function readLocalNodeConfig(nodeId) {
 /** Best-effort persist of node config to local storage. */
 async function writeLocalNodeConfig(nodeId, config) {
     try {
-        await ESPRMNeoStorage.setNodeConfig(nodeId, config);
+        let toStore = config;
+        // Cloud config omits connectivity — keep the last cached status when writing.
+        if (!config.connectivity_status) {
+            const prev = await ESPRMNeoStorage.getNodeConfig(nodeId);
+            if (prev?.connectivity_status) {
+                toStore = {
+                    ...config,
+                    connectivity_status: prev.connectivity_status,
+                };
+            }
+        }
+        await ESPRMNeoStorage.setNodeConfig(nodeId, toStore);
     }
     catch (error) {
         logger.warn(`Cache write failed for ${nodeId}`, error);

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

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

package/dist/esm/utils/waitForNodeOnline.js

@@ -63,11 +63,12 @@ function isNodeOnlineFromShadowPayload(payload) {
  * @throws {ESPProvError} If `timeoutMs` elapses without the node reporting online.
  * @throws {Error} If MQTT connection or subscription fails.
  */
-async function waitForNodeOnline({ nodeId, groupId, user, timeoutMs = DEFAULT_NODE_ONLINE_TIMEOUT_MS, pollIntervalMs = DEFAULT_NODE_ONLINE_POLL_INTERVAL_MS, }) {
-    const shadowName = constructShadowName(groupId);
+async function waitForNodeOnline({ nodeId, groupId, subgroupIds, user, timeoutMs = DEFAULT_NODE_ONLINE_TIMEOUT_MS, pollIntervalMs = DEFAULT_NODE_ONLINE_POLL_INTERVAL_MS, }) {
+    const shadowName = constructShadowName(groupId, subgroupIds ?? []);
     logger.info("Waiting for node to come online", {
         nodeId,
         groupId,
+        subgroupIds: subgroupIds ?? [],
         shadowName,
         timeoutMs,
         pollIntervalMs,
@@ -147,10 +148,10 @@ async function waitForNodeOnline({ nodeId, groupId, user, timeoutMs = DEFAULT_NO
             });
             await user.connectMQTT();
         }
-        // 2. Register (if needed) and subscribe before the shadow may exist
-        if (!alreadyRegistered) {
-            NodeMQTTOrchestrator.registerNode(nodeId, shadowName);
-        }
+        // 2. Bind to the membership shadow and subscribe before the shadow may exist.
+        // Always registerNode so a leftover longer/stale binding for the same nodeId
+        // is rebound to constructShadowName(groupId, subgroupIds).
+        NodeMQTTOrchestrator.registerNode(nodeId, shadowName);
         await NodeMQTTOrchestrator.subscribeToNode(nodeId, onUpdate);
         logger.debug("Subscribed to node shadow for online wait", {
             nodeId,

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

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

package/dist/types/ESPDevice.d.ts

@@ -9,5 +9,15 @@ export declare class ESPDevice implements ESPDeviceInterface {
     name: string;
     transport: string;
     security: number;
+    /**
+     * What a completed association produced, kept so `retryNetworkCredentials`
+     * can resume the flow instead of repeating it. Set once verification
+     * succeeds; `undefined` until then.
+     */
+    provisionResumeState?: {
+        nodeId: string;
+        groupId: string;
+        options?: Record<string, any>;
+    };
     constructor(deviceConfig: ESPDeviceInterface);
 }

package/dist/types/ESPRMNeoNode.d.ts

@@ -22,11 +22,16 @@ export declare class ESPRMNeoNode {
     subgroupIds: string[];
     devices: ESPRMNeoDevice[];
     services: ESPRMNeoService[];
+    /**
+     * Last-known connectivity. Seeded from cached `connectivity_status` when
+     * present (cloud config does not provide it); otherwise starts offline until
+     * an MQTT shadow `online` update arrives.
+     */
     connectivityStatus: ESPRMNeoConnectivityStatusInterface;
     /**
      * Transports currently usable for this node, keyed by mode.
-     * - `mqtt` (cloud) is added when the node reports online and removed when
-     *   it goes offline (via shadow updates or seeded `connectivity_status`).
+     * - `mqtt` (cloud) is added when the node is connected and removed when it
+     *   goes offline (from cached `connectivity_status` or shadow updates).
      * - `local` is added/removed at runtime by a `localDiscovery` subscriber as the
      *   node appears/disappears on the LAN (via {@link addTransport}/{@link removeTransport}).
      * Apps may also add custom string-keyed entries (pair with
@@ -132,11 +137,18 @@ export declare class ESPRMNeoNode {
      */
     private processNodeUpdate;
     /**
-     * Updates {@link connectivityStatus} and MQTT transport availability when the
-     * shadow reports `online`. Partial updates without `online` are ignored so
-     * an existing status is not cleared.
+     * Updates {@link connectivityStatus} when the shadow reports `online`, then
+     * syncs MQTT transport availability. Partial updates without `online` are
+     * ignored so an existing status is not cleared.
      */
     private applyConnectivityStatus;
+    /**
+     * Registers the MQTT transport only while {@link connectivityStatus} reports
+     * the node as connected; removes it when offline.
+     */
+    private syncMqttTransportAvailability;
+    /** Persists {@link wireConfig} (including last-known connectivity) to storage. */
+    private persistWireConfig;
     /** When cloud `ncfg_ver` changes, refetch config and persist the new marker. */
     private refreshConfigIfNcfgChanged;
 }

package/dist/types/methods/ESPDevice/ResetWifiStatus.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Augments the ESPDevice class with the `resetWifiStatus` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Asks the device to clear its Wi-Fi state over the open provisioning session.
+         *
+         * Sent on the network-control endpoint, so it needs an established session and
+         * leaves the user-node association intact — only Wi-Fi credentials are cleared.
+         * That is what makes `retryNetworkCredentials` possible after a wrong password,
+         * instead of making the user factory reset the board.
+         * @returns A promise resolving to `true` when the device acknowledged the reset.
+         */
+        resetWifiStatus(): Promise<boolean>;
+    }
+}
+export {};

package/dist/types/methods/ESPDevice/RetryNetworkCredentials.d.ts

@@ -0,0 +1,22 @@
+import { ESPProvResponse } from "../../types/provision";
+/**
+ * Augments the ESPDevice class with the `retryNetworkCredentials` method.
+ */
+declare module "../../ESPDevice" {
+    interface ESPDevice {
+        /**
+         * Re-sends Wi-Fi credentials after `resetWifiStatus`, resuming the flow the
+         * first attempt started rather than repeating its association.
+         *
+         * Sending credentials alone is not enough: the online wait and the success
+         * report follow them and need the node id the association produced, which
+         * only this SDK holds.
+         * @param ssid - The SSID, unchanged from the first attempt.
+         * @param passphrase - The corrected Wi-Fi password.
+         * @param onProgress - Progress callback; emits the same messages as `provision`.
+         * @returns A promise resolving to the node id.
+         * @throws {ESPProvError} When no association has completed on this device yet.
+         */
+        retryNetworkCredentials(ssid: string, passphrase: string, onProgress: (message: ESPProvResponse) => void): Promise<string>;
+    }
+}

package/dist/types/methods/ESPDevice/index.d.ts

@@ -8,6 +8,8 @@ import "./SetProofOfPossession";
 import "./SendData";
 import "./InitializeSession";
 import "./SetNetworkCredentials";
+import "./ResetWifiStatus";
+import "./RetryNetworkCredentials";
 import "./InitiateUserNodeMapping";
 import "./VerifyUserNodeMapping";
 import "./StartAssistedClaiming";