zwave-js 8.7.8 → 8.8.2

package/build/lib/driver/Driver.js

@@ -69,6 +69,7 @@ const INodeQuery_1 = require("../node/INodeQuery");
 const Types_1 = require("../node/Types");
 const deviceConfig_1 = require("../telemetry/deviceConfig");
 const statistics_1 = require("../telemetry/statistics");
+const MessageGenerators_1 = require("./MessageGenerators");
 const SendThreadMachine_1 = require("./SendThreadMachine");
 const ThrottlePresets_1 = require("./ThrottlePresets");
 const Transaction_1 = require("./Transaction");
@@ -104,7 +105,6 @@ const defaultOptions = {
         openSerialPort: 10,
         controller: 3,
         sendData: 3,
-        retryAfterTransmitReport: false,
         nodeInterview: 5,
     },
     preserveUnknownValues: false,
@@ -209,9 +209,6 @@ class Driver extends shared_1.TypedEventEmitter {
         this.retryNodeInterviewTimeouts = new Map();
         this._statisticsEnabled = false;
         this.isSoftResetting = false;
-        this._cleanupHandler = () => {
-            void this.destroy();
-        };
         this.partialCCSessions = new Map();
         this.lastCallbackId = 0xff;
         this.lastSaveToCache = 0;
@@ -222,11 +219,6 @@ class Driver extends shared_1.TypedEventEmitter {
         this.options = (0, shared_1.mergeDeep)(options, defaultOptions);
         // And make sure they contain valid values
         checkOptions(this.options);
-        // register some cleanup handlers in case the program doesn't get closed cleanly
-        this._cleanupHandler = this._cleanupHandler.bind(this);
-        process.on("exit", this._cleanupHandler);
-        process.on("SIGINT", this._cleanupHandler);
-        process.on("uncaughtException", this._cleanupHandler);
         // Initialize logging
         this._logContainer = new core_1.ZWaveLogContainer(this.options.logConfig);
         this._driverLog = new Driver_1.DriverLogger(this._logContainer);
@@ -291,10 +283,26 @@ class Driver extends shared_1.TypedEventEmitter {
                     if (this.handleMissingNodeACK(transaction))
                         return;
                 }
-                transaction.promise.reject(error);
+                // If the transaction was already started, we need to throw the error into the message generator
+                // so it correctly gets ended. Otherwise just reject the result promise
+                if (transaction.parts.self) {
+                    // eslint-disable-next-line @typescript-eslint/no-empty-function
+                    transaction.parts.self.throw(error).catch(() => { });
+                }
+                else {
+                    transaction.promise.reject(error);
+                }
             },
             resolveTransaction: (transaction, result) => {
-                transaction.promise.resolve(result);
+                // If the transaction was already started, we need to end the message generator early by throwing
+                // the result. Otherwise just resolve the result promise
+                if (transaction.parts.self) {
+                    // eslint-disable-next-line @typescript-eslint/no-empty-function
+                    transaction.parts.self.throw(result).catch(() => { });
+                }
+                else {
+                    transaction.promise.resolve(result);
+                }
             },
             logOutgoingMessage: (msg) => {
                 this.driverLog.logMessage(msg, {
@@ -318,15 +326,30 @@ class Driver extends shared_1.TypedEventEmitter {
                 }
             },
             log: this.driverLog.print.bind(this.driverLog),
+            logQueue: this.driverLog.sendQueue.bind(this.driverLog),
         }, (0, shared_1.pick)(this.options, ["timeouts", "attempts"]));
         this.sendThread = (0, xstate_1.interpret)(sendThreadMachine);
         // this.sendThread.onTransition((state) => {
         // 	if (state.changed)
         // 		this.driverLog.print(
-        // 			`send thread state: ${state.toStrings().slice(-1)[0]}`,
+        // 			`send thread state: ${state.toStrings().join("->")}`,
         // 			"verbose",
         // 		);
         // });
+        // this.sendThread.onEvent((evt) => {
+        // 	if (evt.type === "forward") {
+        // 		this.driverLog.print(
+        // 			// @ts-ignore
+        // 			`forwarding event: ${evt.payload.type} from ${evt.from} to ${evt.to}`,
+        // 			"verbose",
+        // 		);
+        // 	} else {
+        // 		this.driverLog.print(
+        // 			`send thread event: ${evt.type}`,
+        // 			"verbose",
+        // 		);
+        // 	}
+        // });
     }
     ensureNodeSessions(nodeId) {
         if (!this.nodeSessions.has(nodeId)) {
@@ -447,8 +470,14 @@ class Driver extends shared_1.TypedEventEmitter {
         // Everything async (inluding opening the serial port) must happen in the setImmediate callback
         // asynchronously open the serial port
         setImmediate(async () => {
-            if (!(await this.tryOpenSerialport(spOpenPromise)))
+            try {
+                await this.openSerialport();
+            }
+            catch (e) {
+                spOpenPromise.reject(e);
+                void this.destroy();
                 return;
+            }
             this.driverLog.print("serial port opened");
             this._isOpen = true;
             spOpenPromise.resolve();
@@ -507,13 +536,13 @@ class Driver extends shared_1.TypedEventEmitter {
         });
         return spOpenPromise;
     }
-    async tryOpenSerialport(openPromise) {
+    async openSerialport() {
         let lastError;
         // After a reset, the serial port may need a few seconds until we can open it - try a few times
         for (let attempt = 1; attempt <= this.options.attempts.openSerialPort; attempt++) {
             try {
                 await this.serial.open();
-                return true;
+                return;
             }
             catch (e) {
                 lastError = e;
@@ -524,15 +553,7 @@ class Driver extends shared_1.TypedEventEmitter {
         }
         const message = `Failed to open the serial port: ${(0, shared_1.getErrorMessage)(lastError)}`;
         this.driverLog.print(message, "error");
-        const error = new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.Driver_Failed);
-        if (this._isOpen || !openPromise) {
-            this.emit("error", error);
-        }
-        else {
-            openPromise === null || openPromise === void 0 ? void 0 : openPromise.reject(error);
-        }
-        void this.destroy();
-        return false;
+        throw new core_1.ZWaveError(message, core_1.ZWaveErrorCodes.Driver_Failed);
     }
     /** Indicates whether all nodes are ready, i.e. the "all nodes ready" event has been emitted */
     get allNodesReady() {
@@ -1050,9 +1071,14 @@ class Driver extends shared_1.TypedEventEmitter {
     }
     /** Checks if there are any pending transactions that match the given predicate */
     hasPendingTransactions(predicate) {
-        const { queue, currentTransaction } = this.sendThread.state.context;
-        return ((currentTransaction && predicate(currentTransaction)) ||
-            !!queue.find((t) => predicate(t)));
+        const { queue, activeTransactions } = this.sendThread.state.context;
+        if (!!queue.find((t) => predicate(t)))
+            return true;
+        for (const { transaction } of activeTransactions.values()) {
+            if (predicate(transaction))
+                return true;
+        }
+        return false;
     }
     /**
      * Retrieves the maximum version of a command class the given endpoint supports.
@@ -1139,6 +1165,14 @@ class Driver extends shared_1.TypedEventEmitter {
             productId === 0x0001) {
             return false;
         }
+        // Vision Gen5 USB Stick
+        if (manufacturerId === 0x0109 &&
+            productType === 0x1001 &&
+            productId === 0x0201
+        // firmware version 15.1 (GH#3730)
+        ) {
+            return false;
+        }
         return true;
     }
     async rememberNoSoftReset() {
@@ -1200,6 +1234,7 @@ class Driver extends shared_1.TypedEventEmitter {
         return this.softResetInternal(true);
     }
     async softResetInternal(destroyOnError) {
+        var _a;
         this.controllerLog.print("Performing soft reset...");
         try {
             this.isSoftResetting = true;
@@ -1221,8 +1256,11 @@ class Driver extends shared_1.TypedEventEmitter {
             }
         }
         this.isSoftResetting = false;
-        // And resume sending
+        // Resume sending
         this.unpauseSendThread();
+        // Soft-resetting disables any ongoing inclusion, so we need to reset
+        // the state that is tracked in the controller
+        (_a = this._controller) === null || _a === void 0 ? void 0 : _a.setInclusionState(Inclusion_1.InclusionState.Idle);
     }
     async ensureSerialAPI() {
         // Wait 1.5 seconds after reset to ensure that the module is ready for communication again
@@ -1238,7 +1276,12 @@ class Driver extends shared_1.TypedEventEmitter {
         // If the controller disconnected the serial port during the soft reset, we need to re-open it
         if (!this.serial.isOpen) {
             this.controllerLog.print("Re-opening serial port...");
-            await this.tryOpenSerialport();
+            try {
+                await this.openSerialport();
+            }
+            catch {
+                return false;
+            }
         }
         // Wait the configured amount of time for the Serial API started command to be received
         this.controllerLog.print("Waiting for the Serial API to start...");
@@ -1324,27 +1367,12 @@ class Driver extends shared_1.TypedEventEmitter {
      * Must be called under any circumstances.
      */
     async destroy() {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         // Ensure this is only called once and all subsequent calls block
         if (this._destroyPromise)
             return this._destroyPromise;
         this._destroyPromise = (0, deferred_promise_1.createDeferredPromise)();
         this.driverLog.print("destroying driver instance...");
-        // Disable inclusion before shutting down
-        try {
-            switch ((_a = this._controller) === null || _a === void 0 ? void 0 : _a.inclusionState) {
-                case Inclusion_1.InclusionState.SmartStart:
-                case Inclusion_1.InclusionState.Including:
-                    await this._controller.stopInclusionNoCallback();
-                    break;
-                case Inclusion_1.InclusionState.Excluding:
-                    await this._controller.stopExclusionNoCallback();
-                    break;
-            }
-        }
-        catch {
-            // ignore
-        }
         // First stop the send thread machine and close the serial port, so nothing happens anymore
         if (this.sendThread.initialized)
             this.sendThread.stop();
@@ -1364,8 +1392,8 @@ class Driver extends shared_1.TypedEventEmitter {
         }
         try {
             // Attempt to close the value DBs
-            await ((_b = this._valueDB) === null || _b === void 0 ? void 0 : _b.close());
-            await ((_c = this._metadataDB) === null || _c === void 0 ? void 0 : _c.close());
+            await ((_a = this._valueDB) === null || _a === void 0 ? void 0 : _a.close());
+            await ((_b = this._metadataDB) === null || _b === void 0 ? void 0 : _b.close());
         }
         catch (e) {
             this.driverLog.print(`Closing the value DBs failed: ${(0, shared_1.getErrorMessage)(e)}`, "error");
@@ -1383,10 +1411,8 @@ class Driver extends shared_1.TypedEventEmitter {
                 clearTimeout(timeout);
         }
         // Destroy all nodes
-        (_d = this._controller) === null || _d === void 0 ? void 0 : _d.nodes.forEach((n) => n.destroy());
-        process.removeListener("exit", this._cleanupHandler);
-        process.removeListener("SIGINT", this._cleanupHandler);
-        process.removeListener("uncaughtException", this._cleanupHandler);
+        (_c = this._controller) === null || _c === void 0 ? void 0 : _c.nodes.forEach((n) => n.destroy());
+        this.driverLog.print(`driver instance destroyed`);
         // destroy loggers as the very last thing
         this._logContainer.destroy();
         this._destroyPromise.resolve();
@@ -1693,11 +1719,10 @@ class Driver extends shared_1.TypedEventEmitter {
         // If the node does not acknowledge our request, it is either asleep or dead
         e.code === core_1.ZWaveErrorCodes.Controller_CallbackNOK &&
             (transaction.message instanceof SendDataMessages_1.SendDataRequest ||
-                transaction.message instanceof SendDataBridgeMessages_1.SendDataBridgeRequest) &&
-            // Ignore pre-transmit handshakes because the actual transaction will be retried
-            transaction.priority !== Constants_1.MessagePriority.PreTransmitHandshake);
+                transaction.message instanceof SendDataBridgeMessages_1.SendDataBridgeRequest));
     }
     /**
+     * @internal
      * Handles the case that a node failed to respond in time.
      * Returns `true` if the transaction failure was handled, `false` if it needs to be rejected.
      */
@@ -1714,15 +1739,8 @@ class Driver extends shared_1.TypedEventEmitter {
 It is probably asleep, moving its messages to the wakeup queue.`, "warn");
             // Mark the node as asleep
             // The handler for the asleep status will move the messages to the wakeup queue
-            // We need to re-add the current transaction if that is allowed because otherwise it will be dropped silently
-            if (this.mayMoveToWakeupQueue(transaction)) {
-                this.sendThread.send({ type: "add", transaction });
-            }
-            else {
-                transaction.promise.reject(new core_1.ZWaveError(`The node is asleep`, core_1.ZWaveErrorCodes.Controller_MessageDropped));
-            }
             node.markAsAsleep();
-            return true;
+            return this.mayMoveToWakeupQueue(transaction);
         }
         else {
             const errorMsg = `Node ${node.id} did not respond after ${transaction.message.maxSendAttempts} attempts, it is presumed dead`;
@@ -2013,9 +2031,6 @@ ${handlers.length} left`);
      */
     async handleRequest(msg) {
         let handlers;
-        // For further actions, we are only interested in the innermost CC
-        if ((0, ICommandClassContainer_1.isCommandClassContainer)(msg))
-            this.unwrapCommands(msg);
         if ((0, INodeQuery_1.isNodeQuery)(msg) || (0, ICommandClassContainer_1.isCommandClassContainer)(msg)) {
             const node = msg.getNodeUnsafe();
             if (node) {
@@ -2025,7 +2040,17 @@ ${handlers.length} left`);
                 }
             }
         }
+        // Check if we have a dynamic handler waiting for this message
+        for (const entry of this.awaitedMessages) {
+            if (entry.predicate(msg)) {
+                // resolve the promise - this will remove the entry from the list
+                entry.promise.resolve(msg);
+                return;
+            }
+        }
         if ((0, ICommandClassContainer_1.isCommandClassContainer)(msg)) {
+            // For further actions, we are only interested in the innermost CC
+            this.unwrapCommands(msg);
             const node = msg.getNodeUnsafe();
             // If we receive an encrypted message but assume the node is insecure, change our assumption
             if ((node === null || node === void 0 ? void 0 : node.isSecure) === false &&
@@ -2039,6 +2064,7 @@ ${handlers.length} left`);
             if (!this.mayHandleUnsolicitedCommand(msg.command))
                 return;
         }
+        // Otherwise go through the static handlers
         if (msg instanceof ApplicationCommandRequest_1.ApplicationCommandRequest ||
             msg instanceof BridgeApplicationCommandRequest_1.BridgeApplicationCommandRequest) {
             // we handle ApplicationCommandRequests differently because they are handled by the nodes directly
@@ -2190,15 +2216,6 @@ ${handlers.length} left`);
             }
         }
         else {
-            // Check if we have a dynamic handler waiting for this message
-            for (const entry of this.awaitedMessages) {
-                if (entry.predicate(msg)) {
-                    // resolve the promise - this will remove the entry from the list
-                    entry.promise.resolve(msg);
-                    return;
-                }
-            }
-            // Otherwise loop through the static handlers
             // TODO: This deserves a nicer formatting
             this.driverLog.print(`handling request ${Constants_1.FunctionType[msg.functionType]} (${msg.functionType})`);
             handlers = this.requestHandlers.get(msg.functionType);
@@ -2291,13 +2308,62 @@ ${handlers.length} left`);
             msg.command = unwrapped;
         }
     }
+    /**
+     * Gets called whenever any Serial API command succeeded or a SendData command had a negative callback.
+     */
+    handleSerialAPICommandResult(msg, options, result) {
+        var _a, _b;
+        // Update statistics
+        const node = msg.getNodeUnsafe();
+        let success = true;
+        if ((0, SendDataShared_1.isSendData)(msg)) {
+            // This shouldn't happen, but just in case
+            if (!node)
+                return;
+            if ((0, SendDataShared_1.isSendDataTransmitReport)(result)) {
+                if (!result.isOK()) {
+                    success = false;
+                    node.incrementStatistics("commandsDroppedTX");
+                }
+                else {
+                    node.incrementStatistics("commandsTX");
+                }
+                // Notify listeners about the status report
+                if ((0, SendDataShared_1.hasTXReport)(result)) {
+                    (_a = options.onTXReport) === null || _a === void 0 ? void 0 : _a.call(options, result.txReport);
+                    // TODO: Update statistics based on the TX report
+                }
+            }
+        }
+        else {
+            (_b = this._controller) === null || _b === void 0 ? void 0 : _b.incrementStatistics("messagesTX");
+        }
+        // Track and potentially update the status of the node when communication succeeds
+        if (node && success) {
+            if (node.canSleep) {
+                // Do not update the node status when we just responded to a nonce request
+                if (options.priority !== Constants_1.MessagePriority.Handshake) {
+                    // If the node is not meant to be kept awake, try to send it back to sleep
+                    if (!node.keepAwake) {
+                        this.debounceSendNodeToSleep(node);
+                    }
+                    // The node must be awake because it answered
+                    node.markAsAwake();
+                }
+            }
+            else if (node.status !== Types_1.NodeStatus.Alive) {
+                // The node status was unknown or dead - in either case it must be alive because it answered
+                node.markAsAlive();
+            }
+        }
+    }
     /**
      * Sends a message to the Z-Wave stick.
      * @param msg The message to send
      * @param options (optional) Options regarding the message transmission
      */
     async sendMessage(msg, options = {}) {
-        var _a, _b;
+        var _a;
         this.ensureReady();
         let node;
         // Don't send messages to dead nodes
@@ -2342,17 +2408,24 @@ ${handlers.length} left`);
             !(msg instanceof SendDataMessages_1.SendDataMulticastRequest) &&
             !(msg instanceof SendDataBridgeMessages_1.SendDataMulticastBridgeRequest) &&
             // Handshake messages are meant to be sent immediately
-            options.priority !== Constants_1.MessagePriority.Handshake &&
-            options.priority !== Constants_1.MessagePriority.PreTransmitHandshake) {
+            options.priority !== Constants_1.MessagePriority.Handshake) {
             if (options.priority === Constants_1.MessagePriority.NodeQuery) {
                 // Remember that this transaction was part of an interview
                 options.tag = "interview";
             }
             options.priority = Constants_1.MessagePriority.WakeUp;
         }
-        // create the transaction and enqueue it
-        const promise = (0, deferred_promise_1.createDeferredPromise)();
-        const transaction = new Transaction_1.Transaction(this, msg, promise, options.priority);
+        // Create the transaction
+        const { generator, resultPromise } = (0, MessageGenerators_1.createMessageGenerator)(this, msg, (msg, _result) => {
+            this.handleSerialAPICommandResult(msg, options, _result);
+        });
+        const transaction = new Transaction_1.Transaction(this, {
+            message: msg,
+            priority: options.priority,
+            parts: generator,
+            promise: resultPromise,
+        });
+        // Configure its options
         if (options.changeNodeStatusOnMissingACK != undefined) {
             transaction.changeNodeStatusOnTimeout =
                 options.changeNodeStatusOnMissingACK;
@@ -2362,7 +2435,7 @@ ${handlers.length} left`);
         }
         transaction.requestWakeUpOnDemand = !!options.requestWakeUpOnDemand;
         transaction.tag = options.tag;
-        // start sending now (maybe)
+        // And queue it
         this.sendThread.send({ type: "add", transaction });
         // If the transaction should expire, start the timeout
         let expirationTimeout;
@@ -2383,36 +2456,7 @@ ${handlers.length} left`);
             }, options.expire).unref();
         }
         try {
-            const ret = await promise;
-            // The message was transmitted, so it can no longer expire
-            if (expirationTimeout)
-                clearTimeout(expirationTimeout);
-            // Update statistics
-            if ((0, SendDataShared_1.isSendData)(msg)) {
-                node === null || node === void 0 ? void 0 : node.incrementStatistics("commandsTX");
-            }
-            else {
-                (_a = this._controller) === null || _a === void 0 ? void 0 : _a.incrementStatistics("messagesTX");
-            }
-            // Track and potentially update the status of the node when communication succeeds
-            if (node) {
-                if (node.canSleep) {
-                    // Do not update the node status when we just responded to a nonce request
-                    if (options.priority !== Constants_1.MessagePriority.Handshake) {
-                        // If the node is not meant to be kept awake, try to send it back to sleep
-                        if (!node.keepAwake) {
-                            this.debounceSendNodeToSleep(node);
-                        }
-                        // The node must be awake because it answered
-                        node.markAsAwake();
-                    }
-                }
-                else if (node.status !== Types_1.NodeStatus.Alive) {
-                    // The node status was unknown or dead - in either case it must be alive because it answered
-                    node.markAsAlive();
-                }
-            }
-            return ret;
+            return (await resultPromise);
         }
         catch (e) {
             if ((0, core_1.isZWaveError)(e)) {
@@ -2427,24 +2471,28 @@ ${handlers.length} left`);
                     e.context.functionType !== Constants_1.FunctionType.SendDataBridge &&
                     e.context.functionType !==
                         Constants_1.FunctionType.SendDataMulticastBridge) {
-                    (_b = this._controller) === null || _b === void 0 ? void 0 : _b.incrementStatistics("messagesDroppedTX");
+                    (_a = this._controller) === null || _a === void 0 ? void 0 : _a.incrementStatistics("messagesDroppedTX");
                     return e.context;
                 }
                 else if (e.code === core_1.ZWaveErrorCodes.Controller_NodeTimeout) {
                     // If the node failed to respond in time, remember this for the statistics
                     node === null || node === void 0 ? void 0 : node.incrementStatistics("timeoutResponse");
                 }
+                // Enrich errors with the transaction's stack instead of the internal stack
+                if (!e.transactionSource) {
+                    throw new core_1.ZWaveError(e.message, e.code, e.context, transaction.stack);
+                }
             }
             throw e;
         }
+        finally {
+            // The transaction was handled, so it can no longer expire
+            if (expirationTimeout)
+                clearTimeout(expirationTimeout);
+        }
     }
-    /**
-     * Sends a command to a Z-Wave node. If the node returns a command in response, that command will be the return value.
-     * If the command expects no response **or** the response times out, nothing will be returned
-     * @param command The command to send. It will be encapsulated in a SendData[Multicast]Request.
-     * @param options (optional) Options regarding the message transmission
-     */
-    async sendCommand(command, options = {}) {
+    /** Wraps a CC in the correct SendData message to use for sending */
+    createSendDataMessage(command, options = {}) {
         let msg;
         if (command.isSinglecast()) {
             if (this.controller.isFunctionSupported(Constants_1.FunctionType.SendDataBridge)) {
@@ -2456,7 +2504,7 @@ ${handlers.length} left`);
             }
         }
         else if (command.isMulticast()) {
-            if (this.controller.isFunctionSupported(Constants_1.FunctionType.SendDataBridge)) {
+            if (this.controller.isFunctionSupported(Constants_1.FunctionType.SendDataMulticastBridge)) {
                 // Prioritize Bridge commands when they are supported
                 msg = new SendDataBridgeMessages_1.SendDataMulticastBridgeRequest(this, { command });
             }
@@ -2482,6 +2530,16 @@ ${handlers.length} left`);
         // Automatically encapsulate commands before sending
         if (options.autoEncapsulate !== false)
             this.encapsulateCommands(msg);
+        return msg;
+    }
+    /**
+     * Sends a command to a Z-Wave node. If the node returns a command in response, that command will be the return value.
+     * If the command expects no response **or** the response times out, nothing will be returned
+     * @param command The command to send. It will be encapsulated in a SendData[Multicast]Request.
+     * @param options (optional) Options regarding the message transmission
+     */
+    async sendCommand(command, options = {}) {
+        const msg = this.createSendDataMessage(command, options);
         try {
             const resp = await this.sendMessage(msg, options);
             // And unwrap the response if there was any
@@ -2568,7 +2626,7 @@ ${handlers.length} left`);
     /**
      * Waits until an unsolicited serial message is received or a timeout has elapsed. Returns the received message.
      *
-     * **Note:** This does not trigger for [Bridge]ApplicationUpdateRequests, which are handled differently. To wait for a certain CommandClass, use {@link waitForCommand}.
+     * **Note:** To wait for a certain CommandClass, better use {@link waitForCommand}.
      * @param timeout The number of milliseconds to wait. If the timeout elapses, the returned promise will be rejected
      * @param predicate A predicate function to test all incoming messages
      */
@@ -2639,8 +2697,6 @@ ${handlers.length} left`);
             // so they must be dropped
             case (0, NoOperationCC_1.messageIsPing)(msg):
             case transaction.priority === Constants_1.MessagePriority.Handshake:
-            // Outgoing handshake requests are very likely not valid after wakeup, so drop them too
-            case transaction.priority === Constants_1.MessagePriority.PreTransmitHandshake:
             // We also don't want to immediately send the node to sleep when it wakes up
             case (0, ICommandClassContainer_1.isCommandClassContainer)(msg) &&
                 msg.command instanceof WakeUpCC_1.WakeUpCCNoMoreInformation:
@@ -2725,47 +2781,6 @@ ${handlers.length} left`);
     sortSendQueue() {
         this.sendThread.send("sortQueue");
     }
-    /** Re-sends the current command if it is S2 encapsulated */
-    resendS2EncapsulatedCommand() {
-        // If this is called, a receiving node couldn't decode the last message we sent it
-        const { currentTransaction } = this.sendThread.state.context;
-        if (currentTransaction &&
-            (0, ICommandClassContainer_1.isCommandClassContainer)(currentTransaction.message) &&
-            currentTransaction.message.command instanceof
-                commandclass_1.Security2CCMessageEncapsulation) {
-            const cmd = currentTransaction.message.command;
-            if (cmd.wasRetriedAfterDecodeFailure) {
-                this._controllerLog.logNode(cmd.nodeId, {
-                    message: `failed to decode the message after re-transmission with SPAN extension, dropping the message.`,
-                    direction: "none",
-                    level: "warn",
-                });
-                this.sendThread.send({
-                    type: "reduce",
-                    reducer: (_t, source) => {
-                        if (source === "current") {
-                            return {
-                                type: "reject",
-                                code: core_1.ZWaveErrorCodes.Security2CC_CannotDecode,
-                                message: "The node failed to decode the message.",
-                            };
-                        }
-                        else {
-                            return { type: "keep" };
-                        }
-                    },
-                });
-            }
-            else {
-                this._controllerLog.logNode(cmd.nodeId, {
-                    message: `failed to decode the message, retrying with SPAN extension...`,
-                    direction: "none",
-                });
-                cmd.prepareRetryAfterDecodeFailure();
-                this.sendThread.send("resend");
-            }
-        }
-    }
     /**
      * Does the work for saveNetworkToCache. This is not throttled, so any call
      * to this method WILL save the network.