zwave-js 8.5.1 → 8.7.1

package/build/lib/controller/Controller.js

@@ -18,6 +18,7 @@ const deferred_promise_1 = require("alcalzone-shared/deferred-promise");
 const objects_1 = require("alcalzone-shared/objects");
 const typeguards_1 = require("alcalzone-shared/typeguards");
 const crypto_1 = __importDefault(require("crypto"));
+const semver_1 = __importDefault(require("semver"));
 const util_1 = __importDefault(require("util"));
 const commandclass_1 = require("../commandclass");
 const ManufacturerSpecificCC_1 = require("../commandclass/ManufacturerSpecificCC");
@@ -35,6 +36,7 @@ const ExtNVMReadLongByteMessages_1 = require("../serialapi/nvm/ExtNVMReadLongByt
 const ExtNVMWriteLongBufferMessages_1 = require("../serialapi/nvm/ExtNVMWriteLongBufferMessages");
 const ExtNVMWriteLongByteMessages_1 = require("../serialapi/nvm/ExtNVMWriteLongByteMessages");
 const GetNVMIdMessages_1 = require("../serialapi/nvm/GetNVMIdMessages");
+const NVMOperationsMessages_1 = require("../serialapi/nvm/NVMOperationsMessages");
 const AddNodeToNetworkRequest_1 = require("./AddNodeToNetworkRequest");
 const AssignReturnRouteMessages_1 = require("./AssignReturnRouteMessages");
 const AssignSUCReturnRouteMessages_1 = require("./AssignSUCReturnRouteMessages");
@@ -64,9 +66,11 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
         super();
         this.driver = driver;
         this._healNetworkActive = false;
-        this._exclusionActive = false;
-        this._inclusionActive = false;
+        this._provisioningList = [];
+        this._inclusionState = Inclusion_1.InclusionState.Idle;
+        this._smartStartEnabled = false;
         this._includeController = false;
+        this._unprovisionRemovedNode = false;
         this._healNetworkProgress = new Map();
         this._nodes = new Map();
         this._nodes.getOrThrow = function (nodeId) {
@@ -77,9 +81,9 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
             return node;
         }.bind(this._nodes);
         // register message handlers
-        driver.registerRequestHandler(Constants_1.FunctionType.AddNodeToNetwork, this.handleAddNodeRequest.bind(this));
-        driver.registerRequestHandler(Constants_1.FunctionType.RemoveNodeFromNetwork, this.handleRemoveNodeRequest.bind(this));
-        driver.registerRequestHandler(Constants_1.FunctionType.ReplaceFailedNode, this.handleReplaceNodeRequest.bind(this));
+        driver.registerRequestHandler(Constants_1.FunctionType.AddNodeToNetwork, this.handleAddNodeStatusReport.bind(this));
+        driver.registerRequestHandler(Constants_1.FunctionType.RemoveNodeFromNetwork, this.handleRemoveNodeStatusReport.bind(this));
+        driver.registerRequestHandler(Constants_1.FunctionType.ReplaceFailedNode, this.handleReplaceNodeStatusReport.bind(this));
     }
     get libraryVersion() {
         return this._libraryVersion;
@@ -116,6 +120,34 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
     get serialApiVersion() {
         return this._serialApiVersion;
     }
+    /** Checks if the Serial API version is greater than the given one */
+    serialApiGt(version) {
+        if (this._serialApiVersion === undefined) {
+            return undefined;
+        }
+        return semver_1.default.gt((0, shared_1.padVersion)(this._serialApiVersion), (0, shared_1.padVersion)(version));
+    }
+    /** Checks if the Serial API version is greater than or equal to the given one */
+    serialApiGte(version) {
+        if (this._serialApiVersion === undefined) {
+            return undefined;
+        }
+        return semver_1.default.gte((0, shared_1.padVersion)(this._serialApiVersion), (0, shared_1.padVersion)(version));
+    }
+    /** Checks if the Serial API version is lower than the given one */
+    serialApiLt(version) {
+        if (this._serialApiVersion === undefined) {
+            return undefined;
+        }
+        return semver_1.default.lt((0, shared_1.padVersion)(this._serialApiVersion), (0, shared_1.padVersion)(version));
+    }
+    /** Checks if the Serial API version is lower than or equal to the given one */
+    serialApiLte(version) {
+        if (this._serialApiVersion === undefined) {
+            return undefined;
+        }
+        return semver_1.default.lte((0, shared_1.padVersion)(this._serialApiVersion), (0, shared_1.padVersion)(version));
+    }
     get manufacturerId() {
         return this._manufacturerId;
     }
@@ -151,10 +183,32 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
     get supportsTimers() {
         return this._supportsTimers;
     }
+    /** Whether the controller is known to support soft reset */
+    get supportsSoftReset() {
+        return this._supportsSoftReset;
+    }
+    /** @internal */
+    set supportsSoftReset(value) {
+        this._supportsSoftReset = value;
+    }
     /** A dictionary of the nodes connected to this controller */
     get nodes() {
         return this._nodes;
     }
+    /** Returns the node with the given DSK */
+    getNodeByDSK(dsk) {
+        var _a;
+        if (typeof dsk === "string")
+            dsk = (0, core_1.dskFromString)(dsk);
+        for (const node of this._nodes.values()) {
+            if ((_a = node.dsk) === null || _a === void 0 ? void 0 : _a.equals(dsk))
+                return node;
+        }
+    }
+    /** Returns the controller node's value DB */
+    get valueDB() {
+        return this._nodes.get(this._ownNodeId).valueDB;
+    }
     /** Returns whether the network or a node is currently being healed. */
     get isHealNetworkActive() {
         return this._healNetworkActive;
@@ -168,14 +222,130 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
         const nodes = nodeIDs.map((id) => this._nodes.getOrThrow(id));
         return new VirtualNode_1.VirtualNode(undefined, this.driver, nodes);
     }
+    /** @internal */
+    get provisioningList() {
+        return this._provisioningList;
+    }
+    /** Adds the given entry (DSK and security classes) to the controller's SmartStart provisioning list or replaces an existing entry */
+    provisionSmartStartNode(entry) {
+        const index = this._provisioningList.findIndex((e) => e.dsk === entry.dsk);
+        if (index === -1) {
+            this._provisioningList.push(entry);
+        }
+        else {
+            this._provisioningList[index] = entry;
+        }
+        this.autoProvisionSmartStart();
+        void this.driver.saveNetworkToCache();
+    }
+    /**
+     * Removes the given DSK or node ID from the controller's SmartStart provisioning list.
+     *
+     * **Note:** If this entry corresponds to an included node, it will **NOT** be excluded
+     */
+    unprovisionSmartStartNode(dskOrNodeId) {
+        const index = this._provisioningList.findIndex((e) => e.dsk === dskOrNodeId ||
+            (typeof dskOrNodeId === "number" &&
+                "nodeId" in e &&
+                e.nodeId === dskOrNodeId));
+        if (index >= 0) {
+            this._provisioningList.splice(index, 1);
+            this.autoProvisionSmartStart();
+            void this.driver.saveNetworkToCache();
+        }
+    }
+    /**
+     * Returns the entry for the given DSK from the controller's SmartStart provisioning list.
+     */
+    getProvisioningEntry(dsk) {
+        return this._provisioningList.find((e) => e.dsk === dsk);
+    }
+    /**
+     * Returns all entries from the controller's SmartStart provisioning list.
+     */
+    getProvisioningEntries() {
+        // Make copies so no one can modify the internal list (except for user info)
+        return this._provisioningList.map((e) => {
+            const { dsk, securityClasses, nodeId, ...rest } = e;
+            return {
+                dsk,
+                securityClasses: [...securityClasses],
+                ...(nodeId != undefined ? { nodeId } : {}),
+                ...rest,
+            };
+        });
+    }
+    /** Returns whether the SmartStart provisioning list contains entries that have not been included yet */
+    hasPlannedProvisioningEntries() {
+        return this._provisioningList.some((e) => !("nodeId" in e));
+    }
+    /**
+     * @internal
+     * Automatically starts smart start inclusion if there are nodes pending inclusion.
+     */
+    autoProvisionSmartStart() {
+        if (this.hasPlannedProvisioningEntries()) {
+            // SmartStart should be enabled
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            void this.enableSmartStart().catch(() => { });
+        }
+        else {
+            // SmartStart should be disabled
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            void this.disableSmartStart().catch(() => { });
+        }
+    }
+    markNodeOnProvisioningList(node) {
+        // If this node's DSK is on the provisioning list, remember the node ID
+        if (node.dsk) {
+            const entry = this._provisioningList.find((e) => e.dsk === (0, core_1.dskToString)(node.dsk));
+            if (entry)
+                entry.nodeId = node.id;
+        }
+    }
+    unmarkNodeOnProvisioningList(nodeId) {
+        const entry = this._provisioningList.find((e) => "nodeId" in e && e.nodeId === nodeId);
+        if (entry)
+            delete entry.nodeId;
+    }
+    /**
+     * @internal
+     * Queries the controller IDs and its Serial API capabilities
+     */
+    async identify() {
+        // get the home and node id of the controller
+        this.driver.controllerLog.print(`querying controller IDs...`);
+        const ids = await this.driver.sendMessage(new GetControllerIdMessages_1.GetControllerIdRequest(this.driver), { supportCheck: false });
+        this._homeId = ids.homeId;
+        this._ownNodeId = ids.ownNodeId;
+        this.driver.controllerLog.print(`received controller IDs:
+  home ID:     ${(0, shared_1.num2hex)(this._homeId)}
+  own node ID: ${this._ownNodeId}`);
+        // Figure out what the serial API can do
+        this.driver.controllerLog.print(`querying API capabilities...`);
+        const apiCaps = await this.driver.sendMessage(new GetSerialApiCapabilitiesMessages_1.GetSerialApiCapabilitiesRequest(this.driver), {
+            supportCheck: false,
+        });
+        this._serialApiVersion = apiCaps.serialApiVersion;
+        this._manufacturerId = apiCaps.manufacturerId;
+        this._productType = apiCaps.productType;
+        this._productId = apiCaps.productId;
+        this._supportedFunctionTypes = apiCaps.supportedFunctionTypes;
+        this.driver.controllerLog.print(`received API capabilities:
+  serial API version:  ${this._serialApiVersion}
+  manufacturer ID:     ${(0, shared_1.num2hex)(this._manufacturerId)}
+  product type:        ${(0, shared_1.num2hex)(this._productType)}
+  product ID:          ${(0, shared_1.num2hex)(this._productId)}
+  supported functions: ${this._supportedFunctionTypes
+            .map((fn) => `\n  · ${Constants_1.FunctionType[fn]} (${(0, shared_1.num2hex)(fn)})`)
+            .join("")}`);
+    }
     /**
      * @internal
      * Interviews the controller for the necessary information.
-     * @param initValueDBs Asynchronous callback for the driver to initialize the Value DBs before nodes are created
      * @param restoreFromCache Asynchronous callback for the driver to restore the network from cache after nodes are created
      */
-    async interview(initValueDBs, restoreFromCache) {
-        this.driver.controllerLog.print("beginning interview...");
+    async interview(restoreFromCache) {
         // get basic controller version info
         this.driver.controllerLog.print(`querying version info...`);
         const version = await this.driver.sendMessage(new GetControllerVersionMessages_1.GetControllerVersionRequest(this.driver), {
@@ -186,14 +356,6 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
         this.driver.controllerLog.print(`received version info:
   controller type: ${ZWaveLibraryTypes_1.ZWaveLibraryTypes[this._type]}
   library version: ${this._libraryVersion}`);
-        // get the home and node id of the controller
-        this.driver.controllerLog.print(`querying controller IDs...`);
-        const ids = await this.driver.sendMessage(new GetControllerIdMessages_1.GetControllerIdRequest(this.driver), { supportCheck: false });
-        this._homeId = ids.homeId;
-        this._ownNodeId = ids.ownNodeId;
-        this.driver.controllerLog.print(`received controller IDs:
-  home ID:     ${(0, shared_1.num2hex)(this._homeId)}
-  own node ID: ${this._ownNodeId}`);
         // find out what the controller can do
         this.driver.controllerLog.print(`querying controller capabilities...`);
         const ctrlCaps = await this.driver.sendMessage(new GetControllerCapabilitiesMessages_1.GetControllerCapabilitiesRequest(this.driver), {
@@ -211,25 +373,6 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
   is SIS present:      ${this._isSISPresent}
   was real primary:    ${this._wasRealPrimary}
   is a SUC:            ${this._isStaticUpdateController}`);
-        // find out which part of the API is supported
-        this.driver.controllerLog.print(`querying API capabilities...`);
-        const apiCaps = await this.driver.sendMessage(new GetSerialApiCapabilitiesMessages_1.GetSerialApiCapabilitiesRequest(this.driver), {
-            supportCheck: false,
-        });
-        this._serialApiVersion = apiCaps.serialApiVersion;
-        this._manufacturerId = apiCaps.manufacturerId;
-        this._productType = apiCaps.productType;
-        this._productId = apiCaps.productId;
-        this._supportedFunctionTypes = apiCaps.supportedFunctionTypes;
-        this.driver.controllerLog.print(`received API capabilities:
-  serial API version:  ${this._serialApiVersion}
-  manufacturer ID:     ${(0, shared_1.num2hex)(this._manufacturerId)}
-  product type:        ${(0, shared_1.num2hex)(this._productType)}
-  product ID:          ${(0, shared_1.num2hex)(this._productId)}
-  supported functions: ${this._supportedFunctionTypes
-            .map((fn) => `\n  · ${Constants_1.FunctionType[fn]} (${(0, shared_1.num2hex)(fn)})`)
-            .join("")}`);
-        // now we can check if a function is supported
         // Figure out which sub commands of SerialAPISetup are supported
         if (this.isFunctionSupported(Constants_1.FunctionType.SerialAPISetup)) {
             this.driver.controllerLog.print(`querying serial API setup capabilities...`);
@@ -283,8 +426,6 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
             this.isFunctionSupported(Constants_1.FunctionType.FUNC_ID_ZW_GET_VIRTUAL_NODES)) {
             // TODO: send FUNC_ID_ZW_GET_VIRTUAL_NODES message
         }
-        // Give the Driver time to set up the value DBs
-        await initValueDBs();
         // Request information about all nodes with the GetInitData message
         this.driver.controllerLog.print(`querying node information...`);
         const initData = await this.driver.sendMessage(new GetSerialApiInitDataMessages_1.GetSerialApiInitDataRequest(this.driver));
@@ -315,7 +456,7 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
         // Now try to deserialize all nodes from the cache
         await restoreFromCache();
         // Set manufacturer information for the controller node
-        const controllerValueDB = this._nodes.get(this._ownNodeId).valueDB;
+        const controllerValueDB = this.valueDB;
         controllerValueDB.setMetadata((0, ManufacturerSpecificCC_1.getManufacturerIdValueId)(), (0, ManufacturerSpecificCC_1.getManufacturerIdValueMetadata)());
         controllerValueDB.setMetadata((0, ManufacturerSpecificCC_1.getProductTypeValueId)(), (0, ManufacturerSpecificCC_1.getProductTypeValueMetadata)());
         controllerValueDB.setMetadata((0, ManufacturerSpecificCC_1.getProductIdValueId)(), (0, ManufacturerSpecificCC_1.getProductIdValueMetadata)());
@@ -417,9 +558,24 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
             }
         });
     }
+    get inclusionState() {
+        return this._inclusionState;
+    }
+    setInclusionState(state) {
+        if (this._inclusionState === state)
+            return;
+        this._inclusionState = state;
+        if (state === Inclusion_1.InclusionState.Idle && this._smartStartEnabled) {
+            // If Smart Start was enabled before the inclusion/exclusion,
+            // enable it again and ignore errors
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            this.enableSmartStart().catch(() => { });
+        }
+    }
     async beginInclusion(options) {
-        // don't start it twice
-        if (this._inclusionActive || this._exclusionActive) {
+        if (this._inclusionState === Inclusion_1.InclusionState.Including ||
+            this._inclusionState === Inclusion_1.InclusionState.Excluding ||
+            this._inclusionState === Inclusion_1.InclusionState.Busy) {
             return false;
         }
         if (options == undefined) {
@@ -435,97 +591,279 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
             };
         }
         // Protect against invalid inclusion options
-        if (!(options.strategy in Inclusion_1.InclusionStrategy)) {
+        if (!(options.strategy in Inclusion_1.InclusionStrategy) ||
+            // @ts-expect-error We're checking for user errors
+            options.strategy === Inclusion_1.InclusionStrategy.SmartStart) {
             throw new core_1.ZWaveError(`Invalid inclusion strategy: ${options.strategy}`, core_1.ZWaveErrorCodes.Argument_Invalid);
         }
-        if (options.strategy === Inclusion_1.InclusionStrategy.SmartStart) {
-            throw new core_1.ZWaveError(`SmartStart is not supported yet!`, core_1.ZWaveErrorCodes.Driver_NotSupported);
+        if (this._inclusionState === Inclusion_1.InclusionState.SmartStart) {
+            // Disable listening mode so we can switch to inclusion mode
+            await this.stopInclusion();
         }
-        this._inclusionActive = true;
+        this.setInclusionState(Inclusion_1.InclusionState.Including);
         this._inclusionOptions = options;
-        this.driver.controllerLog.print(`Starting inclusion process with strategy ${(0, shared_1.getEnumMemberName)(Inclusion_1.InclusionStrategy, options.strategy)}...`);
-        // create the promise we're going to return
-        this._beginInclusionPromise = (0, deferred_promise_1.createDeferredPromise)();
-        // kick off the inclusion process
+        try {
+            this.driver.controllerLog.print(`Starting inclusion process with strategy ${(0, shared_1.getEnumMemberName)(Inclusion_1.InclusionStrategy, options.strategy)}...`);
+            // kick off the inclusion process
+            await this.driver.sendMessage(new AddNodeToNetworkRequest_1.AddNodeToNetworkRequest(this.driver, {
+                addNodeType: AddNodeToNetworkRequest_1.AddNodeType.Any,
+                highPower: true,
+                networkWide: true,
+            }));
+            this.driver.controllerLog.print(`The controller is now ready to add nodes`);
+            this.emit("inclusion started", 
+            // TODO: Remove first parameter in next major version
+            options.strategy !== Inclusion_1.InclusionStrategy.Insecure, options.strategy);
+        }
+        catch (e) {
+            this.setInclusionState(Inclusion_1.InclusionState.Idle);
+            if ((0, core_1.isZWaveError)(e) &&
+                e.code === core_1.ZWaveErrorCodes.Controller_CallbackNOK) {
+                this.driver.controllerLog.print(`Starting the inclusion failed`, "error");
+                throw new core_1.ZWaveError("The inclusion could not be started.", core_1.ZWaveErrorCodes.Controller_InclusionFailed);
+            }
+            throw e;
+        }
+        return true;
+    }
+    /** @internal */
+    async beginInclusionSmartStart(provisioningEntry) {
+        if (this._inclusionState === Inclusion_1.InclusionState.Including ||
+            this._inclusionState === Inclusion_1.InclusionState.Excluding ||
+            this._inclusionState === Inclusion_1.InclusionState.Busy) {
+            return false;
+        }
+        // Disable listening mode so we can switch to inclusion mode
+        await this.stopInclusion();
+        this.setInclusionState(Inclusion_1.InclusionState.Including);
+        this._inclusionOptions = {
+            strategy: Inclusion_1.InclusionStrategy.SmartStart,
+            provisioning: provisioningEntry,
+        };
+        try {
+            this.driver.controllerLog.print(`Including SmartStart node with DSK ${provisioningEntry.dsk}`);
+            // kick off the inclusion process
+            const dskBuffer = (0, core_1.dskFromString)(provisioningEntry.dsk);
+            await this.driver.sendMessage(new AddNodeToNetworkRequest_1.AddNodeDSKToNetworkRequest(this.driver, {
+                nwiHomeId: (0, core_1.nwiHomeIdFromDSK)(dskBuffer),
+                authHomeId: (0, core_1.authHomeIdFromDSK)(dskBuffer),
+                highPower: true,
+                networkWide: true,
+            }));
+            this.emit("inclusion started", 
+            // TODO: Remove first parameter in next major version
+            true, Inclusion_1.InclusionStrategy.SmartStart);
+        }
+        catch (e) {
+            this.setInclusionState(Inclusion_1.InclusionState.Idle);
+            // Error handling for this happens at the call site
+            throw e;
+        }
+        return true;
+    }
+    /**
+     * Is used internally to stop an active inclusion process without waiting for a confirmation
+     * @internal
+     */
+    async stopInclusionNoCallback() {
         await this.driver.sendMessage(new AddNodeToNetworkRequest_1.AddNodeToNetworkRequest(this.driver, {
-            addNodeType: AddNodeToNetworkRequest_1.AddNodeType.Any,
+            callbackId: 0,
+            addNodeType: AddNodeToNetworkRequest_1.AddNodeType.Stop,
             highPower: true,
             networkWide: true,
         }));
-        return this._beginInclusionPromise;
+        this.driver.controllerLog.print(`The inclusion process was stopped`);
+        this.emit("inclusion stopped");
     }
-    /** Is used internally to stop an active inclusion process without creating deadlocks */
-    async stopInclusionInternal() {
-        // don't stop it twice
-        if (!this._inclusionActive)
-            return;
-        this._inclusionActive = false;
-        this.driver.controllerLog.print(`stopping inclusion process...`);
-        // create the promise we're going to return
-        this._stopInclusionPromise = (0, deferred_promise_1.createDeferredPromise)();
-        // kick off the inclusion process
-        await this.driver.sendMessage(new AddNodeToNetworkRequest_1.AddNodeToNetworkRequest(this.driver, {
+    /**
+     * Finishes an inclusion process. This must only be called after the ProtocolDone status is received.
+     * Returns the ID of the newly added node.
+     */
+    async finishInclusion() {
+        this.driver.controllerLog.print(`finishing inclusion process...`);
+        const response = await this.driver.sendMessage(new AddNodeToNetworkRequest_1.AddNodeToNetworkRequest(this.driver, {
             addNodeType: AddNodeToNetworkRequest_1.AddNodeType.Stop,
             highPower: true,
             networkWide: true,
         }));
-        // Don't await the promise or we create a deadlock
-        void this._stopInclusionPromise.then(() => {
-            this.driver.controllerLog.print(`the inclusion process was stopped`);
-            this.emit("inclusion stopped");
-        });
+        if (response.status === AddNodeToNetworkRequest_1.AddNodeStatus.Done) {
+            return response.statusContext.nodeId;
+        }
+        this.driver.controllerLog.print(`Finishing the inclusion failed`, "error");
+        throw new core_1.ZWaveError("Finishing the inclusion failed", core_1.ZWaveErrorCodes.Controller_InclusionFailed);
     }
     /**
      * Stops an active inclusion process. Resolves to true when the controller leaves inclusion mode,
      * and false if the inclusion was not active.
      */
     async stopInclusion() {
-        // don't stop it twice
-        if (!this._inclusionActive)
+        if (this._inclusionState !== Inclusion_1.InclusionState.Including) {
             return false;
-        await this.stopInclusionInternal();
-        return this._stopInclusionPromise;
+        }
+        this.driver.controllerLog.print(`stopping inclusion process...`);
+        try {
+            // stop the inclusion process
+            await this.driver.sendMessage(new AddNodeToNetworkRequest_1.AddNodeToNetworkRequest(this.driver, {
+                addNodeType: AddNodeToNetworkRequest_1.AddNodeType.Stop,
+                highPower: true,
+                networkWide: true,
+            }));
+            this.driver.controllerLog.print(`The inclusion process was stopped`);
+            this.emit("inclusion stopped");
+            this.setInclusionState(Inclusion_1.InclusionState.Idle);
+            return true;
+        }
+        catch (e) {
+            if ((0, core_1.isZWaveError)(e) &&
+                e.code === core_1.ZWaveErrorCodes.Controller_CallbackNOK) {
+                this.driver.controllerLog.print(`Stopping the inclusion failed`, "error");
+                throw new core_1.ZWaveError("The inclusion could not be stopped.", core_1.ZWaveErrorCodes.Controller_InclusionFailed);
+            }
+            throw e;
+        }
+    }
+    /**
+     * Puts the controller into listening mode for Smart Start inclusion.
+     * Whenever a node on the provisioning list announces itself, it will automatically be added.
+     *
+     * Resolves to `true` when the listening mode is started or was active, and `false` if it is scheduled for later activation.
+     */
+    async enableSmartStart() {
+        this._smartStartEnabled = true;
+        if (this._inclusionState === Inclusion_1.InclusionState.Idle) {
+            this.setInclusionState(Inclusion_1.InclusionState.SmartStart);
+            this.driver.controllerLog.print(`Enabling Smart Start listening mode...`);
+            try {
+                await this.driver.sendMessage(new AddNodeToNetworkRequest_1.EnableSmartStartListenRequest(this.driver, {}));
+                this.driver.controllerLog.print(`Smart Start listening mode enabled`);
+                return true;
+            }
+            catch (e) {
+                this.setInclusionState(Inclusion_1.InclusionState.Idle);
+                this.driver.controllerLog.print(`Smart Start listening mode could not be enabled: ${(0, shared_1.getErrorMessage)(e)}`, "error");
+                throw e;
+            }
+        }
+        else if (this._inclusionState === Inclusion_1.InclusionState.SmartStart) {
+            return true;
+        }
+        else {
+            this.driver.controllerLog.print(`Smart Start listening mode scheduled for later activation...`);
+            return false;
+        }
+    }
+    /**
+     * Disables the listening mode for Smart Start inclusion.
+     *
+     * Resolves to `true` when the listening mode is stopped, and `false` if was not active.
+     */
+    async disableSmartStart() {
+        this._smartStartEnabled = false;
+        if (this._inclusionState === Inclusion_1.InclusionState.SmartStart) {
+            this.setInclusionState(Inclusion_1.InclusionState.Idle);
+            this.driver.controllerLog.print(`disabling Smart Start listening mode...`);
+            try {
+                await this.stopInclusion();
+                this.driver.controllerLog.print(`Smart Start listening mode disabled`);
+                return true;
+            }
+            catch (e) {
+                this.setInclusionState(Inclusion_1.InclusionState.SmartStart);
+                this.driver.controllerLog.print(`Smart Start listening mode could not be disabled: ${(0, shared_1.getErrorMessage)(e)}`, "error");
+                throw e;
+            }
+        }
+        else if (this._inclusionState === Inclusion_1.InclusionState.Idle) {
+            return true;
+        }
+        else {
+            this.driver.controllerLog.print(`Smart Start listening mode disabled`);
+            return true;
+        }
     }
     /**
      * Starts the exclusion process of new nodes.
-     * Resolves to true when the process was started,
-     * and false if an inclusion or exclusion process was already active
+     * Resolves to true when the process was started, and false if an inclusion or exclusion process was already active.
+     *
+     * @param unprovision Whether the removed node should also be removed from the Smart Start provisioning list.
      */
-    async beginExclusion() {
-        // don't start it twice
-        if (this._inclusionActive || this._exclusionActive)
+    async beginExclusion(unprovision = false) {
+        if (this._inclusionState === Inclusion_1.InclusionState.Including ||
+            this._inclusionState === Inclusion_1.InclusionState.Excluding ||
+            this._inclusionState === Inclusion_1.InclusionState.Busy) {
             return false;
-        this._exclusionActive = true;
+        }
+        if (this._inclusionState === Inclusion_1.InclusionState.SmartStart) {
+            // Disable listening mode so we can switch to exclusion mode
+            await this.stopInclusion();
+        }
+        this.setInclusionState(Inclusion_1.InclusionState.Excluding);
         this.driver.controllerLog.print(`starting exclusion process...`);
-        // create the promise we're going to return
-        this._beginInclusionPromise = (0, deferred_promise_1.createDeferredPromise)();
-        // kick off the inclusion process
-        await this.driver.sendMessage(new RemoveNodeFromNetworkRequest_1.RemoveNodeFromNetworkRequest(this.driver, {
-            removeNodeType: RemoveNodeFromNetworkRequest_1.RemoveNodeType.Any,
-            highPower: true,
-            networkWide: true,
-        }));
-        return this._beginInclusionPromise;
+        try {
+            // kick off the inclusion process
+            await this.driver.sendMessage(new RemoveNodeFromNetworkRequest_1.RemoveNodeFromNetworkRequest(this.driver, {
+                removeNodeType: RemoveNodeFromNetworkRequest_1.RemoveNodeType.Any,
+                highPower: true,
+                networkWide: true,
+            }));
+            this.driver.controllerLog.print(`The controller is now ready to remove nodes`);
+            this._unprovisionRemovedNode = unprovision;
+            this.emit("exclusion started");
+            return true;
+        }
+        catch (e) {
+            this.setInclusionState(Inclusion_1.InclusionState.Idle);
+            if ((0, core_1.isZWaveError)(e) &&
+                e.code === core_1.ZWaveErrorCodes.Controller_CallbackNOK) {
+                this.driver.controllerLog.print(`Starting the exclusion failed`, "error");
+                throw new core_1.ZWaveError("The exclusion could not be started.", core_1.ZWaveErrorCodes.Controller_ExclusionFailed);
+            }
+            throw e;
+        }
     }
-    /** Is used internally to stop an active inclusion process without creating deadlocks */
-    async stopExclusionInternal() {
-        // don't stop it twice
-        if (!this._exclusionActive)
-            return;
-        this._exclusionActive = false;
-        this.driver.controllerLog.print(`stopping exclusion process...`);
-        // create the promise we're going to return
-        this._stopInclusionPromise = (0, deferred_promise_1.createDeferredPromise)();
-        // kick off the inclusion process
+    /**
+     * Is used internally to stop an active exclusion process without waiting for confirmation
+     * @internal
+     */
+    async stopExclusionNoCallback() {
         await this.driver.sendMessage(new RemoveNodeFromNetworkRequest_1.RemoveNodeFromNetworkRequest(this.driver, {
+            callbackId: 0,
             removeNodeType: RemoveNodeFromNetworkRequest_1.RemoveNodeType.Stop,
             highPower: true,
             networkWide: true,
         }));
-        void this._stopInclusionPromise.then(() => {
+        this.driver.controllerLog.print(`the exclusion process was stopped`);
+        this.emit("exclusion stopped");
+    }
+    /**
+     * Stops an active exclusion process. Resolves to true when the controller leaves exclusion mode,
+     * and false if the inclusion was not active.
+     */
+    async stopExclusion() {
+        if (this._inclusionState !== Inclusion_1.InclusionState.Excluding) {
+            return false;
+        }
+        this.driver.controllerLog.print(`stopping exclusion process...`);
+        try {
+            // kick off the inclusion process
+            await this.driver.sendMessage(new RemoveNodeFromNetworkRequest_1.RemoveNodeFromNetworkRequest(this.driver, {
+                removeNodeType: RemoveNodeFromNetworkRequest_1.RemoveNodeType.Stop,
+                highPower: true,
+                networkWide: true,
+            }));
             this.driver.controllerLog.print(`the exclusion process was stopped`);
             this.emit("exclusion stopped");
-        });
+            this.setInclusionState(Inclusion_1.InclusionState.Idle);
+            return true;
+        }
+        catch (e) {
+            if ((0, core_1.isZWaveError)(e) &&
+                e.code === core_1.ZWaveErrorCodes.Controller_CallbackNOK) {
+                this.driver.controllerLog.print(`Stopping the exclusion failed`, "error");
+                throw new core_1.ZWaveError("The exclusion could not be stopped.", core_1.ZWaveErrorCodes.Controller_ExclusionFailed);
+            }
+            throw e;
+        }
     }
     async secureBootstrapS0(node, assumeSupported = false) {
         if (!this.driver.securityManager) {
@@ -617,7 +955,34 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
                 version: 1,
             });
         }
-        const { userCallbacks } = this._inclusionOptions;
+        let userCallbacks;
+        const inclusionOptions = this
+            ._inclusionOptions;
+        if ("provisioning" in inclusionOptions) {
+            // SmartStart and S2 with QR code are pre-provisioned, so we don't need to ask the user for anything
+            userCallbacks = {
+                // eslint-disable-next-line @typescript-eslint/no-empty-function
+                abort() { },
+                grantSecurityClasses: (requested) => {
+                    return Promise.resolve({
+                        clientSideAuth: false,
+                        securityClasses: requested.securityClasses.filter((r) => inclusionOptions.provisioning.securityClasses.includes(r)),
+                    });
+                },
+                validateDSKAndEnterPIN: (dsk) => {
+                    const fullDSK = inclusionOptions.provisioning.dsk;
+                    const pin = fullDSK.slice(0, 5);
+                    // Make sure the DSK matches
+                    if (pin + dsk !== fullDSK)
+                        return Promise.resolve(false);
+                    return Promise.resolve(pin);
+                },
+            };
+        }
+        else {
+            // Use the provided callbacks
+            userCallbacks = inclusionOptions.userCallbacks;
+        }
         const deleteTempKey = () => {
             var _a, _b;
             // Whatever happens, no further communication needs the temporary key
@@ -739,16 +1104,27 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
                 return abort();
             }
             const nodePublicKey = pubKeyResponse.publicKey;
-            // This is the starting point of the timer TAI2. Depending on how long the user takes to confirm,
-            // the node has less time to send its KEXSet
+            // This is the starting point of the timer TAI2.
             const timerStartTAI2 = Date.now();
+            // Generate ECDH key pair. We need to immediately send the other node our public key,
+            // so it won't abort bootstrapping
+            const keyPair = await util_1.default.promisify(crypto_1.default.generateKeyPair)("x25519");
+            const publicKey = (0, core_1.decodeX25519KeyDER)(keyPair.publicKey.export({
+                type: "spki",
+                format: "der",
+            }));
+            await api.sendPublicKey(publicKey);
+            // After this, the node will start sending us a KEX SET every 10 seconds.
+            // We won't be able to decode it until the DSK was verified
             if (grantedKeys.includes(core_1.SecurityClass.S2_AccessControl) ||
                 grantedKeys.includes(core_1.SecurityClass.S2_Authenticated)) {
                 // For authenticated encryption, the DSK (first 16 bytes of the public key) is obfuscated (missing the first 2 bytes)
                 // Request the user to enter the missing part as a 5-digit PIN
                 const dsk = (0, core_1.dskToString)(nodePublicKey.slice(0, 16)).slice(5);
+                // The time the user has to enter the PIN is limited by the timeout TAI2
+                const tai2RemainingMs = shared_2.inclusionTimeouts.TAI2 - (Date.now() - timerStartTAI2);
                 const pinResult = await Promise.race([
-                    (0, async_1.wait)(shared_2.inclusionTimeouts.TAI2, true).then(() => false),
+                    (0, async_1.wait)(tai2RemainingMs, true).then(() => false),
                     userCallbacks
                         .validateDSKAndEnterPIN(dsk)
                         // ignore errors in application callbacks
@@ -766,12 +1142,8 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
                 // Fill in the missing two bytes of the public key
                 nodePublicKey.writeUInt16BE(parseInt(pinResult, 10), 0);
             }
-            // Generate ECDH key pair. Z-Wave works with the "raw" keys, so this is a tad complicated
-            const keyPair = await util_1.default.promisify(crypto_1.default.generateKeyPair)("x25519");
-            const publicKey = (0, core_1.decodeX25519KeyDER)(keyPair.publicKey.export({
-                type: "spki",
-                format: "der",
-            }));
+            // After the user has verified the DSK, we can derive the shared secret
+            // Z-Wave works with the "raw" keys, so this is a tad complicated
             const sharedSecret = crypto_1.default.diffieHellman({
                 publicKey: crypto_1.default.createPublicKey({
                     key: (0, core_1.encodeX25519KeyDERSPKI)(nodePublicKey),
@@ -780,15 +1152,14 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
                 }),
                 privateKey: keyPair.privateKey,
             });
-            // Derive temporary key from ECDH key pair
+            // Derive temporary key from ECDH key pair - this will allow us to receive the node's KEX SET commands
             const tempKeys = (0, core_1.deriveTempKeys)((0, core_1.computePRK)(sharedSecret, publicKey, nodePublicKey));
+            this.driver.securityManager2.deleteNonce(node.id);
             this.driver.securityManager2.tempKeys.set(node.id, {
                 keyCCM: tempKeys.tempKeyCCM,
                 personalizationString: tempKeys.tempPersonalizationString,
             });
-            await api.sendPublicKey(publicKey);
-            // Wait until the encrypted KEXSet from the node was received
-            // (if there is even time left)
+            // Now wait for the next KEXSet from the node (if there is even time left)
             const tai2RemainingMs = shared_2.inclusionTimeouts.TAI2 - (Date.now() - timerStartTAI2);
             if (tai2RemainingMs < 1) {
                 this.driver.controllerLog.logNode(node.id, {
@@ -905,6 +1276,8 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
             for (const securityClass of core_1.securityClassOrder) {
                 node.securityClasses.set(securityClass, grantedKeys.includes(securityClass));
             }
+            // Remember the DSK (first 16 bytes of the public key)
+            node.dsk = nodePublicKey.slice(0, 16);
             this.driver.controllerLog.logNode(node.id, {
                 message: `Security S2 bootstrapping successful with these security classes:${[
                     ...node.securityClasses.entries(),
@@ -1031,60 +1404,32 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
             }
         }
     }
-    /**
-     * Stops an active exclusion process. Resolves to true when the controller leaves exclusion mode,
-     * and false if the inclusion was not active.
-     */
-    async stopExclusion() {
-        // don't stop it twice
-        if (!this._exclusionActive)
-            return false;
-        await this.stopExclusionInternal();
-        return this._stopInclusionPromise;
-    }
     /**
      * Is called when an AddNode request is received from the controller.
      * Handles and controls the inclusion process.
      */
-    async handleAddNodeRequest(msg) {
+    async handleAddNodeStatusReport(msg) {
         var _a, _b, _c, _d, _e, _f, _g;
         this.driver.controllerLog.print(`handling add node request (status = ${AddNodeToNetworkRequest_1.AddNodeStatus[msg.status]})`);
-        if ((!this._inclusionActive && msg.status !== AddNodeToNetworkRequest_1.AddNodeStatus.Done) ||
+        if (this._inclusionState !== Inclusion_1.InclusionState.Including ||
             this._inclusionOptions == undefined) {
             this.driver.controllerLog.print(`  inclusion is NOT active, ignoring it...`);
             return true; // Don't invoke any more handlers
         }
         switch (msg.status) {
-            case AddNodeToNetworkRequest_1.AddNodeStatus.Ready:
-                // this is called when inclusion was started successfully
-                this.driver.controllerLog.print(`  the controller is now ready to add nodes`);
-                if (this._beginInclusionPromise != null) {
-                    this._beginInclusionPromise.resolve(true);
-                    this.emit("inclusion started", 
-                    // TODO: Remove first parameter in next major version
-                    this._inclusionOptions.strategy !==
-                        Inclusion_1.InclusionStrategy.Insecure, this._inclusionOptions.strategy);
-                }
-                break;
             case AddNodeToNetworkRequest_1.AddNodeStatus.Failed:
-                // this is called when inclusion could not be started...
-                if (this._beginInclusionPromise != null) {
-                    this.driver.controllerLog.print(`  starting the inclusion failed`, "error");
-                    this._beginInclusionPromise.reject(new core_1.ZWaveError("The inclusion could not be started.", core_1.ZWaveErrorCodes.Controller_InclusionFailed));
-                }
-                else {
-                    // ...or adding a node failed
-                    this.driver.controllerLog.print(`  adding the node failed`, "error");
-                    this.emit("inclusion failed");
-                }
+                // This code is handled elsewhere for starting the inclusion, so this means
+                // that adding a node failed
+                this.driver.controllerLog.print(`Adding the node failed`, "error");
+                this.emit("inclusion failed");
                 // in any case, stop the inclusion process so we don't accidentally add another node
                 try {
-                    await this.stopInclusionInternal();
+                    await this.stopInclusion();
                 }
                 catch {
                     /* ok */
                 }
-                break;
+                return true; // Don't invoke any more handlers
             case AddNodeToNetworkRequest_1.AddNodeStatus.AddingController:
                 this._includeController = true;
             // fall through!
@@ -1101,103 +1446,113 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
             case AddNodeToNetworkRequest_1.AddNodeStatus.ProtocolDone: {
                 // this is called after a new node is added
                 // stop the inclusion process so we don't accidentally add another node
+                let nodeId;
                 try {
-                    await this.stopInclusionInternal();
+                    nodeId = await this.finishInclusion();
                 }
                 catch {
-                    /* ok */
+                    // ignore the error
                 }
-                break;
-            }
-            case AddNodeToNetworkRequest_1.AddNodeStatus.Done: {
-                // this is called when the inclusion was completed
-                this.driver.controllerLog.print(`done called for ${msg.statusContext.nodeId}`);
-                // stopping the inclusion was acknowledged by the controller
-                if (this._stopInclusionPromise != null)
-                    this._stopInclusionPromise.resolve(true);
-                if (msg.statusContext.nodeId === core_1.NODE_ID_BROADCAST) {
+                // It is recommended to send another STOP command to the controller
+                try {
+                    await this.stopInclusionNoCallback();
+                }
+                catch {
+                    // ignore the error
+                }
+                if (!nodeId || !this._nodePendingInclusion) {
+                    // The inclusion did not succeed
+                    this.setInclusionState(Inclusion_1.InclusionState.Idle);
+                    this._nodePendingInclusion = undefined;
+                    return true;
+                }
+                else if (nodeId === core_1.NODE_ID_BROADCAST) {
                     // No idea how this can happen but it dit at least once
                     this.driver.controllerLog.print(`Cannot add a node with the Node ID ${core_1.NODE_ID_BROADCAST}, aborting...`, "warn");
+                    this.setInclusionState(Inclusion_1.InclusionState.Idle);
                     this._nodePendingInclusion = undefined;
+                    return true;
                 }
-                else if (this._nodePendingInclusion != null) {
-                    const newNode = this._nodePendingInclusion;
-                    const supportedCommandClasses = [
-                        ...newNode.implementedCommandClasses.entries(),
-                    ]
-                        .filter(([, info]) => info.isSupported)
-                        .map(([cc]) => cc);
-                    const controlledCommandClasses = [
-                        ...newNode.implementedCommandClasses.entries(),
-                    ]
-                        .filter(([, info]) => info.isControlled)
-                        .map(([cc]) => cc);
-                    this.driver.controllerLog.print(`finished adding node ${newNode.id}:
+                // We're technically done with the inclusion but should not include
+                // anything else until the node has been bootstrapped
+                this.setInclusionState(Inclusion_1.InclusionState.Busy);
+                // Inclusion is now completed, bootstrap the node
+                const newNode = this._nodePendingInclusion;
+                const supportedCommandClasses = [
+                    ...newNode.implementedCommandClasses.entries(),
+                ]
+                    .filter(([, info]) => info.isSupported)
+                    .map(([cc]) => cc);
+                const controlledCommandClasses = [
+                    ...newNode.implementedCommandClasses.entries(),
+                ]
+                    .filter(([, info]) => info.isControlled)
+                    .map(([cc]) => cc);
+                this.driver.controllerLog.print(`finished adding node ${newNode.id}:
   basic device class:    ${(_a = newNode.deviceClass) === null || _a === void 0 ? void 0 : _a.basic.label}
   generic device class:  ${(_b = newNode.deviceClass) === null || _b === void 0 ? void 0 : _b.generic.label}
   specific device class: ${(_c = newNode.deviceClass) === null || _c === void 0 ? void 0 : _c.specific.label}
   supported CCs: ${supportedCommandClasses
-                        .map((cc) => `\n  · ${core_1.CommandClasses[cc]} (${(0, shared_1.num2hex)(cc)})`)
-                        .join("")}
+                    .map((cc) => `\n  · ${core_1.CommandClasses[cc]} (${(0, shared_1.num2hex)(cc)})`)
+                    .join("")}
   controlled CCs: ${controlledCommandClasses
-                        .map((cc) => `\n  · ${core_1.CommandClasses[cc]} (${(0, shared_1.num2hex)(cc)})`)
-                        .join("")}`);
-                    // remember the node
-                    this._nodes.set(newNode.id, newNode);
-                    this._nodePendingInclusion = undefined;
-                    // We're communicating with the device, so assume it is alive
-                    // If it is actually a sleeping device, it will be marked as such later
-                    newNode.markAsAlive();
-                    // Assign SUC return route to make sure the node knows where to get its routes from
-                    newNode.hasSUCReturnRoute = await this.assignSUCReturnRoute(newNode.id);
-                    const opts = this._inclusionOptions;
-                    // The default inclusion strategy is: Use S2 if possible, only use S0 if necessary, use no encryption otherwise
-                    let lowSecurity = false;
-                    if (newNode.supportsCC(core_1.CommandClasses["Security 2"]) &&
-                        (opts.strategy === Inclusion_1.InclusionStrategy.Default ||
-                            opts.strategy === Inclusion_1.InclusionStrategy.Security_S2)) {
-                        await this.secureBootstrapS2(newNode);
-                        const actualSecurityClass = newNode.getHighestSecurityClass();
-                        if (actualSecurityClass == undefined ||
-                            actualSecurityClass <
-                                core_1.SecurityClass.S2_Unauthenticated) {
-                            lowSecurity = true;
-                        }
+                    .map((cc) => `\n  · ${core_1.CommandClasses[cc]} (${(0, shared_1.num2hex)(cc)})`)
+                    .join("")}`);
+                // remember the node
+                this._nodes.set(newNode.id, newNode);
+                this._nodePendingInclusion = undefined;
+                // We're communicating with the device, so assume it is alive
+                // If it is actually a sleeping device, it will be marked as such later
+                newNode.markAsAlive();
+                // Assign SUC return route to make sure the node knows where to get its routes from
+                newNode.hasSUCReturnRoute = await this.assignSUCReturnRoute(newNode.id);
+                const opts = this._inclusionOptions;
+                // The default inclusion strategy is: Use S2 if possible, only use S0 if necessary, use no encryption otherwise
+                let lowSecurity = false;
+                if (newNode.supportsCC(core_1.CommandClasses["Security 2"]) &&
+                    (opts.strategy === Inclusion_1.InclusionStrategy.Default ||
+                        opts.strategy === Inclusion_1.InclusionStrategy.Security_S2 ||
+                        opts.strategy === Inclusion_1.InclusionStrategy.SmartStart)) {
+                    await this.secureBootstrapS2(newNode);
+                    const actualSecurityClass = newNode.getHighestSecurityClass();
+                    if (actualSecurityClass == undefined ||
+                        actualSecurityClass < core_1.SecurityClass.S2_Unauthenticated) {
+                        lowSecurity = true;
                     }
-                    else if (newNode.supportsCC(core_1.CommandClasses.Security) &&
-                        (opts.strategy === Inclusion_1.InclusionStrategy.Security_S0 ||
-                            (opts.strategy === Inclusion_1.InclusionStrategy.Default &&
-                                (opts.forceSecurity ||
-                                    ((_g = ((_e = (_d = newNode.deviceClass) === null || _d === void 0 ? void 0 : _d.specific) !== null && _e !== void 0 ? _e : (_f = newNode.deviceClass) === null || _f === void 0 ? void 0 : _f.generic)) === null || _g === void 0 ? void 0 : _g.requiresSecurity))))) {
-                        await this.secureBootstrapS0(newNode);
-                        const actualSecurityClass = newNode.getHighestSecurityClass();
-                        if (actualSecurityClass == undefined ||
-                            actualSecurityClass < core_1.SecurityClass.S0_Legacy) {
-                            lowSecurity = true;
-                        }
+                }
+                else if (newNode.supportsCC(core_1.CommandClasses.Security) &&
+                    (opts.strategy === Inclusion_1.InclusionStrategy.Security_S0 ||
+                        (opts.strategy === Inclusion_1.InclusionStrategy.Default &&
+                            (opts.forceSecurity ||
+                                ((_g = ((_e = (_d = newNode.deviceClass) === null || _d === void 0 ? void 0 : _d.specific) !== null && _e !== void 0 ? _e : (_f = newNode.deviceClass) === null || _f === void 0 ? void 0 : _f.generic)) === null || _g === void 0 ? void 0 : _g.requiresSecurity))))) {
+                    await this.secureBootstrapS0(newNode);
+                    const actualSecurityClass = newNode.getHighestSecurityClass();
+                    if (actualSecurityClass == undefined ||
+                        actualSecurityClass < core_1.SecurityClass.S0_Legacy) {
+                        lowSecurity = true;
                     }
-                    this._includeController = false;
-                    // Bootstrap the node's lifelines, so it knows where the controller is
-                    await this.bootstrapLifelineAndWakeup(newNode);
-                    // We're done adding this node, notify listeners
-                    const result = {};
-                    if (lowSecurity)
-                        result.lowSecurity = true;
-                    this.emit("node added", newNode, result);
                 }
-                break;
+                this._includeController = false;
+                // Bootstrap the node's lifelines, so it knows where the controller is
+                await this.bootstrapLifelineAndWakeup(newNode);
+                // We're done adding this node, notify listeners
+                const result = {};
+                if (lowSecurity)
+                    result.lowSecurity = true;
+                this.markNodeOnProvisioningList(newNode);
+                this.emit("node added", newNode, result);
+                this.setInclusionState(Inclusion_1.InclusionState.Idle);
+                return true; // Don't invoke any more handlers
             }
-            default:
-                // not sure what to do with this message
-                return false;
         }
-        return true; // Don't invoke any more handlers
+        // not sure what to do with this message
+        return false;
     }
     /**
      * Is called when an ReplaceFailed request is received from the controller.
      * Handles and controls the replace process.
      */
-    async handleReplaceNodeRequest(msg) {
+    async handleReplaceNodeStatusReport(msg) {
         var _a, _b, _c;
         this.driver.controllerLog.print(`handling replace node request (status = ${ReplaceFailedNodeRequest_1.ReplaceFailedNodeStatus[msg.replaceStatus]})`);
         if (this._inclusionOptions == undefined) {
@@ -1206,9 +1561,11 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
         }
         switch (msg.replaceStatus) {
             case ReplaceFailedNodeRequest_1.ReplaceFailedNodeStatus.NodeOK:
+                this.setInclusionState(Inclusion_1.InclusionState.Idle);
                 (_a = this._replaceFailedPromise) === null || _a === void 0 ? void 0 : _a.reject(new core_1.ZWaveError(`The node could not be replaced because it has responded`, core_1.ZWaveErrorCodes.ReplaceFailedNode_NodeOK));
                 break;
             case ReplaceFailedNodeRequest_1.ReplaceFailedNodeStatus.FailedNodeReplaceFailed:
+                this.setInclusionState(Inclusion_1.InclusionState.Idle);
                 (_b = this._replaceFailedPromise) === null || _b === void 0 ? void 0 : _b.reject(new core_1.ZWaveError(`The failed node has not been replaced`, core_1.ZWaveErrorCodes.ReplaceFailedNode_Failed));
                 break;
             case ReplaceFailedNodeRequest_1.ReplaceFailedNodeStatus.FailedNodeReplace:
@@ -1219,7 +1576,7 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
                 // TODO: Remove first parameter in next major version
                 this._inclusionOptions.strategy !==
                     Inclusion_1.InclusionStrategy.Insecure, this._inclusionOptions.strategy);
-                this._inclusionActive = true;
+                this.setInclusionState(Inclusion_1.InclusionState.Including);
                 (_c = this._replaceFailedPromise) === null || _c === void 0 ? void 0 : _c.resolve(true);
                 // stop here, don't emit inclusion failed
                 return true;
@@ -1228,7 +1585,11 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
                 this.emit("inclusion stopped");
                 if (this._nodePendingReplace) {
                     this.emit("node removed", this._nodePendingReplace, true);
+                    this.unmarkNodeOnProvisioningList(this._nodePendingReplace.id);
                     this._nodes.delete(this._nodePendingReplace.id);
+                    // We're technically done with the replacing but should not include
+                    // anything else until the node has been bootstrapped
+                    this.setInclusionState(Inclusion_1.InclusionState.Busy);
                     // Create a fresh node instance and forget the old one
                     const newNode = new Node_1.ZWaveNode(this._nodePendingReplace.id, this.driver, undefined, undefined, undefined, 
                     // Create an empty value DB and specify that it contains no values
@@ -1268,6 +1629,8 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
                     const result = {};
                     if (lowSecurity)
                         result.lowSecurity = true;
+                    this.setInclusionState(Inclusion_1.InclusionState.Idle);
+                    this.markNodeOnProvisioningList(newNode);
                     this.emit("node added", newNode, result);
                 }
                 // stop here, don't emit inclusion failed
@@ -1280,40 +1643,26 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
      * Is called when a RemoveNode request is received from the controller.
      * Handles and controls the exclusion process.
      */
-    async handleRemoveNodeRequest(msg) {
+    async handleRemoveNodeStatusReport(msg) {
         this.driver.controllerLog.print(`handling remove node request (status = ${RemoveNodeFromNetworkRequest_1.RemoveNodeStatus[msg.status]})`);
-        if (!this._exclusionActive && msg.status !== RemoveNodeFromNetworkRequest_1.RemoveNodeStatus.Done) {
+        if (this._inclusionState !== Inclusion_1.InclusionState.Excluding) {
             this.driver.controllerLog.print(`  exclusion is NOT active, ignoring it...`);
             return true; // Don't invoke any more handlers
         }
         switch (msg.status) {
-            case RemoveNodeFromNetworkRequest_1.RemoveNodeStatus.Ready:
-                // this is called when inclusion was started successfully
-                this.driver.controllerLog.print(`  the controller is now ready to remove nodes`);
-                if (this._beginInclusionPromise != null) {
-                    this._beginInclusionPromise.resolve(true);
-                    this.emit("exclusion started");
-                }
-                break;
             case RemoveNodeFromNetworkRequest_1.RemoveNodeStatus.Failed:
-                // this is called when inclusion could not be started...
-                if (this._beginInclusionPromise != null) {
-                    this.driver.controllerLog.print(`  starting the exclusion failed`, "error");
-                    this._beginInclusionPromise.reject(new core_1.ZWaveError("The exclusion could not be started.", core_1.ZWaveErrorCodes.Controller_ExclusionFailed));
-                }
-                else {
-                    // ...or removing a node failed
-                    this.driver.controllerLog.print(`  removing the node failed`, "error");
-                    this.emit("exclusion failed");
-                }
+                // This code is handled elsewhere for starting the exclusion, so this means
+                // that removing a node failed
+                this.driver.controllerLog.print(`Removing the node failed`, "error");
+                this.emit("exclusion failed");
                 // in any case, stop the exclusion process so we don't accidentally remove another node
                 try {
-                    await this.stopExclusionInternal();
+                    await this.stopExclusion();
                 }
                 catch {
                     /* ok */
                 }
-                break;
+                return true; // Don't invoke any more handlers
             case RemoveNodeFromNetworkRequest_1.RemoveNodeStatus.RemovingSlave:
             case RemoveNodeFromNetworkRequest_1.RemoveNodeStatus.RemovingController: {
                 // this is called when a node is removed
@@ -1324,29 +1673,33 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
                 // this is called when the exclusion was completed
                 // stop the exclusion process so we don't accidentally remove another node
                 try {
-                    await this.stopExclusionInternal();
+                    await this.stopExclusionNoCallback();
                 }
                 catch {
                     /* ok */
                 }
-                // stopping the inclusion was acknowledged by the controller
-                if (this._stopInclusionPromise != null)
-                    this._stopInclusionPromise.resolve(true);
-                if (this._nodePendingExclusion != null) {
-                    this.driver.controllerLog.print(`Node ${this._nodePendingExclusion.id} was removed`);
-                    // notify listeners
-                    this.emit("node removed", this._nodePendingExclusion, false);
-                    // and forget the node
-                    this._nodes.delete(this._nodePendingExclusion.id);
-                    this._nodePendingExclusion = undefined;
+                if (!this._nodePendingExclusion) {
+                    // The exclusion did not succeed
+                    this.setInclusionState(Inclusion_1.InclusionState.Idle);
+                    return true;
                 }
-                break;
+                const nodeId = this._nodePendingExclusion.id;
+                this.driver.controllerLog.print(`Node ${nodeId} was removed`);
+                // Avoid automatic re-inclusion using SmartStart if desired
+                if (this._unprovisionRemovedNode)
+                    this.unprovisionSmartStartNode(nodeId);
+                // notify listeners
+                this.emit("node removed", this._nodePendingExclusion, false);
+                // and forget the node
+                this.unmarkNodeOnProvisioningList(nodeId);
+                this._nodes.delete(nodeId);
+                this._nodePendingExclusion = undefined;
+                this.setInclusionState(Inclusion_1.InclusionState.Idle);
+                return true; // Don't invoke any more handlers
             }
-            default:
-                // not sure what to do with this message
-                return false;
         }
-        return true; // Don't invoke any more handlers
+        // not sure what to do with this message
+        return false;
     }
     /**
      * Performs a healing process for all alive nodes in the network,
@@ -2123,15 +2476,23 @@ ${associatedNodes.join(", ")}`,
                     // Emit the removed event so the driver and applications can react
                     this.emit("node removed", this.nodes.get(nodeId), false);
                     // and forget the node
+                    this.unmarkNodeOnProvisioningList(nodeId);
                     this._nodes.delete(nodeId);
                     return;
             }
         }
     }
     async replaceFailedNode(nodeId, options) {
-        // don't start it twice
-        if (this._inclusionActive || this._exclusionActive)
+        if (this._inclusionState === Inclusion_1.InclusionState.Including ||
+            this._inclusionState === Inclusion_1.InclusionState.Excluding ||
+            this._inclusionState === Inclusion_1.InclusionState.Busy) {
             return false;
+        }
+        if (this._inclusionState === Inclusion_1.InclusionState.SmartStart) {
+            // Disable listening mode so we can switch to exclusion mode
+            await this.stopInclusion();
+        }
+        this.setInclusionState(Inclusion_1.InclusionState.Busy);
         if (options == undefined) {
             options = {
                 strategy: Inclusion_1.InclusionStrategy.Security_S0,
@@ -2147,6 +2508,7 @@ ${associatedNodes.join(", ")}`,
         this.driver.controllerLog.print(`starting replace failed node process...`);
         const node = this.nodes.getOrThrow(nodeId);
         if (await node.ping()) {
+            this.setInclusionState(Inclusion_1.InclusionState.Idle);
             throw new core_1.ZWaveError(`The node replace process could not be started because the node responded to a ping.`, core_1.ZWaveErrorCodes.ReplaceFailedNode_Failed);
         }
         this._inclusionOptions = options;
@@ -2172,6 +2534,7 @@ ${associatedNodes.join(", ")}`,
                 ReplaceFailedNodeRequest_1.ReplaceFailedNodeStartFlags.ReplaceFailed)) {
                 message += `\n· The controller is busy or the node has responded`;
             }
+            this.setInclusionState(Inclusion_1.InclusionState.Idle);
             throw new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.ReplaceFailedNode_Failed);
         }
         else {
@@ -2187,7 +2550,8 @@ ${associatedNodes.join(", ")}`,
         if (result instanceof SerialAPISetupMessages_1.SerialAPISetup_CommandUnsupportedResponse) {
             throw new core_1.ZWaveError(`Your hardware does not support setting the RF region!`, core_1.ZWaveErrorCodes.Driver_NotSupported);
         }
-        // TODO: Issue soft reset
+        if (result.success)
+            await this.driver.trySoftReset();
         return result.success;
     }
     /** Request the current RF region configured at the Z-Wave API Module */
@@ -2285,6 +2649,18 @@ ${associatedNodes.join(", ")}`,
      */
     serialize() {
         return {
+            controller: {
+                supportsSoftReset: this.supportsSoftReset,
+                provisioningList: this.provisioningList.map((e) => {
+                    const { dsk, securityClasses, ...rest } = e;
+                    return {
+                        dsk,
+                        securityClasses: securityClasses.map((s) => core_1.SecurityClass[s]),
+                        // The user-defined properties are saved as-is
+                        ...rest,
+                    };
+                }),
+            },
             nodes: (0, objects_1.composeObject)([...this.nodes.entries()].map(([id, node]) => [id.toString(), node.serialize()])),
         };
     }
@@ -2293,6 +2669,43 @@ ${associatedNodes.join(", ")}`,
      * Deserializes the controller information and all nodes from the cache.
      */
     async deserialize(serialized) {
+        if ((0, typeguards_1.isObject)(serialized.controller)) {
+            // Parse whether the controller supports soft reset
+            if (typeof serialized.controller.supportsSoftReset === "boolean") {
+                this.supportsSoftReset =
+                    serialized.controller.supportsSoftReset;
+            }
+            // Parse the controller's Smart Start provisioning list
+            if ((0, typeguards_1.isArray)(serialized.controller.provisioningList)) {
+                entries: for (const entry of serialized.controller
+                    .provisioningList) {
+                    if (!(0, typeguards_1.isObject)(entry))
+                        continue;
+                    const { dsk, securityClasses: secClasses, ...rest } = entry;
+                    if (typeof entry.dsk !== "string")
+                        continue;
+                    if (!(0, typeguards_1.isArray)(entry.securityClasses))
+                        continue;
+                    if (!(0, core_1.isValidDSK)(entry.dsk))
+                        continue;
+                    const securityClasses = [];
+                    for (const s of secClasses) {
+                        if (typeof s !== "string")
+                            continue entries;
+                        const secClass = core_1.SecurityClass[s];
+                        if (typeof secClass !== "number")
+                            continue entries;
+                        securityClasses.push(secClass);
+                    }
+                    this._provisioningList.push({
+                        dsk: entry.dsk,
+                        securityClasses,
+                        // The user-defined properties are not validated further
+                        ...rest,
+                    });
+                }
+            }
+        }
         if ((0, typeguards_1.isObject)(serialized.nodes)) {
             for (const nodeId of Object.keys(serialized.nodes)) {
                 const serializedNode = serialized.nodes[nodeId];
@@ -2302,9 +2715,9 @@ ${associatedNodes.join(", ")}`,
                     throw new core_1.ZWaveError("The cache file is invalid", core_1.ZWaveErrorCodes.Driver_InvalidCache);
                 }
                 if (this.nodes.has(serializedNode.id)) {
-                    await this.nodes
-                        .get(serializedNode.id)
-                        .deserialize(serializedNode);
+                    const node = this.nodes.getOrThrow(serializedNode.id);
+                    await node.deserialize(serializedNode);
+                    this.markNodeOnProvisioningList(node);
                 }
             }
         }
@@ -2321,17 +2734,27 @@ ${associatedNodes.join(", ")}`,
             return false;
         }
     }
-    /** Returns information of the controller's external NVM */
+    /**
+     * **Z-Wave 500 series only**
+     *
+     * Returns information of the controller's external NVM
+     */
     async getNVMId() {
         const ret = await this.driver.sendMessage(new GetNVMIdMessages_1.GetNVMIdRequest(this.driver));
         return (0, shared_1.pick)(ret, ["nvmManufacturerId", "memoryType", "memorySize"]);
     }
-    /** Reads a byte from the external NVM at the given offset */
+    /**
+     * **Z-Wave 500 series only**
+     *
+     * Reads a byte from the external NVM at the given offset
+     */
     async externalNVMReadByte(offset) {
         const ret = await this.driver.sendMessage(new ExtNVMReadLongByteMessages_1.ExtNVMReadLongByteRequest(this.driver, { offset }));
         return ret.byte;
     }
     /**
+     * **Z-Wave 500 series only**
+     *
      * Writes a byte to the external NVM at the given offset
      * **WARNING:** This function can write in the full NVM address space and is not offset to start at the application area.
      * Take care not to accidentally overwrite the protocol NVM area!
@@ -2342,12 +2765,46 @@ ${associatedNodes.join(", ")}`,
         const ret = await this.driver.sendMessage(new ExtNVMWriteLongByteMessages_1.ExtNVMWriteLongByteRequest(this.driver, { offset, byte: data }));
         return ret.success;
     }
-    /** Reads a buffer from the external NVM at the given offset */
+    /**
+     * **Z-Wave 500 series only**
+     *
+     * Reads a buffer from the external NVM at the given offset
+     */
     async externalNVMReadBuffer(offset, length) {
-        const ret = await this.driver.sendMessage(new ExtNVMReadLongBufferMessages_1.ExtNVMReadLongBufferRequest(this.driver, { offset, length }));
+        const ret = await this.driver.sendMessage(new ExtNVMReadLongBufferMessages_1.ExtNVMReadLongBufferRequest(this.driver, {
+            offset,
+            length,
+        }));
         return ret.buffer;
     }
     /**
+     * **Z-Wave 700 series only**
+     *
+     * Reads a buffer from the external NVM at the given offset
+     */
+    async externalNVMReadBuffer700(offset, length) {
+        const ret = await this.driver.sendMessage(new NVMOperationsMessages_1.NVMOperationsReadRequest(this.driver, {
+            offset,
+            length,
+        }));
+        if (!ret.isOK()) {
+            let message = "Could not read from the external NVM";
+            if (ret.status === NVMOperationsMessages_1.NVMOperationStatus.Error_OperationInterference) {
+                message += ": interference between read and write operation.";
+            }
+            else if (ret.status === NVMOperationsMessages_1.NVMOperationStatus.Error_OperationMismatch) {
+                message += ": wrong operation requested.";
+            }
+            throw new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.Controller_CommandError);
+        }
+        return {
+            buffer: ret.buffer,
+            endOfFile: ret.status === NVMOperationsMessages_1.NVMOperationStatus.EndOfFile,
+        };
+    }
+    /**
+     * **Z-Wave 500 series only**
+     *
      * Writes a buffer to the external NVM at the given offset
      * **WARNING:** This function can write in the full NVM address space and is not offset to start at the application area.
      * Take care not to accidentally overwrite the protocol NVM area!
@@ -2361,16 +2818,86 @@ ${associatedNodes.join(", ")}`,
         }));
         return ret.success;
     }
+    /**
+     * **Z-Wave 700 series only**
+     *
+     * Writes a buffer to the external NVM at the given offset
+     * **WARNING:** This function can write in the full NVM address space and is not offset to start at the application area.
+     * Take care not to accidentally overwrite the protocol NVM area!
+     */
+    async externalNVMWriteBuffer700(offset, buffer) {
+        const ret = await this.driver.sendMessage(new NVMOperationsMessages_1.NVMOperationsWriteRequest(this.driver, {
+            offset,
+            buffer,
+        }));
+        if (!ret.isOK()) {
+            let message = "Could not write to the external NVM";
+            if (ret.status === NVMOperationsMessages_1.NVMOperationStatus.Error_OperationInterference) {
+                message += ": interference between read and write operation.";
+            }
+            else if (ret.status === NVMOperationsMessages_1.NVMOperationStatus.Error_OperationMismatch) {
+                message += ": wrong operation requested.";
+            }
+            throw new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.Controller_CommandError);
+        }
+        return {
+            endOfFile: ret.status === NVMOperationsMessages_1.NVMOperationStatus.EndOfFile,
+        };
+    }
+    /**
+     * **Z-Wave 700 series only**
+     *
+     * Opens the controller's external NVM for reading/writing and returns the NVM size
+     */
+    async externalNVMOpen() {
+        const ret = await this.driver.sendMessage(new NVMOperationsMessages_1.NVMOperationsOpenRequest(this.driver));
+        if (!ret.isOK()) {
+            throw new core_1.ZWaveError("Failed to open the external NVM", core_1.ZWaveErrorCodes.Controller_CommandError);
+        }
+        return ret.offsetOrSize;
+    }
+    /**
+     * **Z-Wave 700 series only**
+     *
+     * Closes the controller's external NVM
+     */
+    async externalNVMClose() {
+        const ret = await this.driver.sendMessage(new NVMOperationsMessages_1.NVMOperationsCloseRequest(this.driver));
+        if (!ret.isOK()) {
+            throw new core_1.ZWaveError("Failed to close the external NVM", core_1.ZWaveErrorCodes.Controller_CommandError);
+        }
+    }
     /**
      * Creates a backup of the NVM and returns the raw data as a Buffer. The Z-Wave radio is turned off/on automatically.
      * @param onProgress Can be used to monitor the progress of the operation, which may take several seconds up to a few minutes depending on the NVM size
      * @returns The raw NVM buffer
      */
     async backupNVMRaw(onProgress) {
+        this.driver.controllerLog.print("Backing up NVM...");
         // Turn Z-Wave radio off to avoid having the protocol write to the NVM while dumping it
         if (!(await this.toggleRF(false))) {
             throw new core_1.ZWaveError("Could not turn off the Z-Wave radio before creating NVM backup!", core_1.ZWaveErrorCodes.Controller_ResponseNOK);
         }
+        let ret;
+        try {
+            if (this.serialApiGte("7.0")) {
+                ret = await this.backupNVMRaw700(onProgress);
+            }
+            else {
+                ret = await this.backupNVMRaw500(onProgress);
+            }
+            this.driver.controllerLog.print("NVM backup completed");
+        }
+        finally {
+            // Whatever happens, turn Z-Wave radio back on
+            await this.toggleRF(true);
+        }
+        // TODO: You can also get away with eliding all the 0xff pages. The NVR also holds the page size of the NVM (NVMP),
+        // so you can figure out which pages you don't have to save or restore. If you do this, you need to make sure to issue a
+        // "factory reset" before restoring the NVM - that'll blank out the NVM to 0xffs before initializing it.
+        return ret;
+    }
+    async backupNVMRaw500(onProgress) {
         const size = (0, GetNVMIdMessages_1.nvmSizeToBufferSize)((await this.getNVMId()).memorySize);
         if (!size) {
             throw new core_1.ZWaveError("Unknown NVM size - cannot backup!", core_1.ZWaveErrorCodes.Controller_NotSupported);
@@ -2396,11 +2923,40 @@ ${associatedNodes.join(", ")}`,
             if (onProgress)
                 setImmediate(() => onProgress(offset, size));
         }
-        // TODO: You can also get away with eliding all the 0xff pages. The NVR also holds the page size of the NVM (NVMP),
-        // so you can figure out which pages you don't have to save or restore. If you do this, you need to make sure to issue a
-        // "factory reset" before restoring the NVM - that'll blank out the NVM to 0xffs before initializing it.
-        // Turn Z-Wave radio back on
-        await this.toggleRF(true);
+        return ret;
+    }
+    async backupNVMRaw700(onProgress) {
+        // Open NVM for reading
+        const size = await this.externalNVMOpen();
+        const ret = Buffer.allocUnsafe(size);
+        let offset = 0;
+        // Try reading the maximum size at first, the Serial API should return chunks in a size it supports
+        // For some reason, there is no documentation and no official command for this
+        let chunkSize = Math.min(0xff, ret.length);
+        try {
+            while (offset < ret.length) {
+                const { buffer: chunk, endOfFile } = await this.externalNVMReadBuffer700(offset, Math.min(chunkSize, ret.length - offset));
+                if (chunkSize === 0xff && chunk.length === 0) {
+                    // Some SDK versions return an empty buffer when trying to read a buffer that is too long
+                    // Fallback to a sane (but maybe slow) size
+                    chunkSize = 48;
+                    continue;
+                }
+                chunk.copy(ret, offset);
+                offset += chunk.length;
+                if (chunkSize > chunk.length)
+                    chunkSize = chunk.length;
+                // Report progress for listeners
+                if (onProgress)
+                    setImmediate(() => onProgress(offset, size));
+                if (endOfFile)
+                    break;
+            }
+        }
+        finally {
+            // Whatever happens, close the NVM
+            await this.externalNVMClose();
+        }
         return ret;
     }
     /**
@@ -2411,10 +2967,36 @@ ${associatedNodes.join(", ")}`,
      * @param onProgress Can be used to monitor the progress of the operation, which may take several seconds up to a few minutes depending on the NVM size
      */
     async restoreNVMRaw(nvmData, onProgress) {
+        this.driver.controllerLog.print("Restoring NVM...");
         // Turn Z-Wave radio off to avoid having the protocol write to the NVM while dumping it
         if (!(await this.toggleRF(false))) {
             throw new core_1.ZWaveError("Could not turn off the Z-Wave radio before restoring NVM backup!", core_1.ZWaveErrorCodes.Controller_ResponseNOK);
         }
+        try {
+            if (this.serialApiGte("7.0")) {
+                await this.restoreNVMRaw700(nvmData, onProgress);
+            }
+            else {
+                await this.restoreNVMRaw500(nvmData, onProgress);
+            }
+            this.driver.controllerLog.print("NVM backup restored");
+        }
+        finally {
+            // Whatever happens, turn Z-Wave radio back on
+            await this.toggleRF(true);
+        }
+        // TODO: You can also get away with eliding all the 0xff pages. The NVR also holds the page size of the NVM (NVMP),
+        // so you can figure out which pages you don't have to save or restore. If you do this, you need to make sure to issue a
+        // "factory reset" before restoring the NVM - that'll blank out the NVM to 0xffs before initializing it.
+        if (this.driver.options.enableSoftReset) {
+            this.driver.controllerLog.print("Activating restored NVM backup...");
+            await this.driver.softReset();
+        }
+        else {
+            this.driver.controllerLog.print("Soft reset not enabled, cannot automatically activate restored NVM backup!", "warn");
+        }
+    }
+    async restoreNVMRaw500(nvmData, onProgress) {
         const size = (0, GetNVMIdMessages_1.nvmSizeToBufferSize)((await this.getNVMId()).memorySize);
         if (!size) {
             throw new core_1.ZWaveError("Unknown NVM size - cannot restore!", core_1.ZWaveErrorCodes.Controller_NotSupported);
@@ -2422,9 +3004,6 @@ ${associatedNodes.join(", ")}`,
         else if (size !== nvmData.length) {
             throw new core_1.ZWaveError("The given data does not match the NVM size - cannot restore!", core_1.ZWaveErrorCodes.Argument_Invalid);
         }
-        // TODO: You can also get away with eliding all the 0xff pages. The NVR also holds the page size of the NVM (NVMP),
-        // so you can figure out which pages you don't have to save or restore. If you do this, you need to make sure to issue a
-        // "factory reset" before restoring the NVM - that'll blank out the NVM to 0xffs before initializing it.
         // Figure out the maximum chunk size the Serial API supports
         // For some reason, there is no documentation and no official command for this
         // The write requests need 5 bytes more than the read response, so subtract 5 from the returned length
@@ -2435,9 +3014,31 @@ ${associatedNodes.join(", ")}`,
             if (onProgress)
                 setImmediate(() => onProgress(offset, size));
         }
-        // Turn Z-Wave radio back on
-        await this.toggleRF(true);
-        // TODO: Soft Reset
+    }
+    async restoreNVMRaw700(nvmData, onProgress) {
+        // Open NVM for reading
+        const size = await this.externalNVMOpen();
+        if (size !== nvmData.length) {
+            throw new core_1.ZWaveError("The given data does not match the NVM size - cannot restore!", core_1.ZWaveErrorCodes.Argument_Invalid);
+        }
+        // Figure out the maximum chunk size the Serial API supports
+        // For some reason, there is no documentation and no official command for this
+        // The write requests have the same size as the read response - if this yields no
+        // data, default to a sane (but maybe slow) size
+        const chunkSize = (await this.externalNVMReadBuffer700(0, 0xff)).buffer.length || 48;
+        // Close NVM and re-open again for writing
+        await this.externalNVMClose();
+        await this.externalNVMOpen();
+        for (let offset = 0; offset < nvmData.length; offset += chunkSize) {
+            const { endOfFile } = await this.externalNVMWriteBuffer700(offset, nvmData.slice(offset, offset + chunkSize));
+            // Report progress for listeners
+            if (onProgress)
+                setImmediate(() => onProgress(offset, size));
+            if (endOfFile)
+                break;
+        }
+        // Close NVM
+        await this.externalNVMClose();
     }
 };
 ZWaveController = __decorate([