zwave-js 11.0.0 → 11.2.0

package/build/lib/driver/Driver.js

@@ -36,6 +36,7 @@ const serial_1 = require("@zwave-js/serial");
 const shared_1 = require("@zwave-js/shared");
 const async_1 = require("alcalzone-shared/async");
 const deferred_promise_1 = require("alcalzone-shared/deferred-promise");
+const sorted_list_1 = require("alcalzone-shared/sorted-list");
 const typeguards_1 = require("alcalzone-shared/typeguards");
 const crypto_1 = require("crypto");
 const fs_extra_1 = __importDefault(require("fs-extra"));
@@ -62,7 +63,8 @@ const statistics_1 = require("../telemetry/statistics");
 const Bootloader_1 = require("./Bootloader");
 const MessageGenerators_1 = require("./MessageGenerators");
 const NetworkCache_1 = require("./NetworkCache");
-const SendThreadMachine_1 = require("./SendThreadMachine");
+const SerialAPICommandMachine_1 = require("./SerialAPICommandMachine");
+const StateMachineShared_1 = require("./StateMachineShared");
 const ThrottlePresets_1 = require("./ThrottlePresets");
 const Transaction_1 = require("./Transaction");
 const TransportServiceMachine_1 = require("./TransportServiceMachine");
@@ -188,13 +190,16 @@ class Driver extends shared_1.TypedEventEmitter {
     constructor(port, options) {
         super();
         this.port = port;
+        this.queuePaused = false;
         /** A map of handlers for all sorts of requests */
         this.requestHandlers = new Map();
-        /** A map of awaited messages */
+        /** A list of awaited message headers */
+        this.awaitedMessageHeaders = [];
+        /** A list of awaited messages */
         this.awaitedMessages = [];
-        /** A map of awaited commands */
+        /** A list of awaited commands */
         this.awaitedCommands = [];
-        /** A map of awaited chunks from the bootloader */
+        /** A list of awaited chunks from the bootloader */
         this.awaitedBootloaderChunks = [];
         /** A map of Node ID -> ongoing sessions */
         this.nodeSessions = new Map();
@@ -268,9 +273,7 @@ class Driver extends shared_1.TypedEventEmitter {
          * Returns the next session ID for Transport Service CC
          */
         this.getNextTransportServiceSessionId = (0, shared_1.createWrappingCounter)(core_1.MAX_TRANSPORT_SERVICE_SESSION_ID, true);
-        this.lastSaveToCache = 0;
-        this.saveToCacheInterval = 150;
-        this.isSavingToCache = false;
+        this.drainQueueBusy = false;
         this.sendNodeToSleepTimers = new Map();
         this._enteringBootloader = false;
         this.lastBackgroundRSSITimestamp = 0;
@@ -300,131 +303,8 @@ class Driver extends shared_1.TypedEventEmitter {
             logContainer: this._logContainer,
             deviceConfigPriorityDir: this._options.storage.deviceConfigPriorityDir,
         });
-        // And initialize but don't start the send thread machine
-        const sendThreadMachine = (0, SendThreadMachine_1.createSendThreadMachine)({
-            sendData: this.writeSerial.bind(this),
-            createSendDataAbort: () => new SendDataMessages_1.SendDataAbort(this),
-            notifyUnsolicited: (msg) => {
-                void this.handleUnsolicitedMessage(msg);
-            },
-            notifyRetry: (command, lastError, message, attempts, maxAttempts, delay) => {
-                if (command === "SendData") {
-                    this.controllerLog.logNode(message.getNodeId() ?? 255, `did not respond after ${attempts}/${maxAttempts} attempts. Scheduling next try in ${delay} ms.`, "warn");
-                }
-                else {
-                    // Translate the error into a better one
-                    let errorReason;
-                    switch (lastError) {
-                        case "response timeout":
-                            errorReason = "No response from controller";
-                            this._controller?.incrementStatistics("timeoutResponse");
-                            break;
-                        case "callback timeout":
-                            errorReason = "No callback from controller";
-                            this._controller?.incrementStatistics("timeoutCallback");
-                            break;
-                        case "response NOK":
-                            errorReason =
-                                "The controller response indicated failure";
-                            break;
-                        case "callback NOK":
-                            errorReason =
-                                "The controller callback indicated failure";
-                            break;
-                        case "ACK timeout":
-                            this._controller?.incrementStatistics("timeoutACK");
-                        // fall through
-                        case "CAN":
-                        case "NAK":
-                        default:
-                            errorReason =
-                                "Failed to execute controller command";
-                            break;
-                    }
-                    this.controllerLog.print(`${errorReason} after ${attempts}/${maxAttempts} attempts. Scheduling next try in ${delay} ms.`, "warn");
-                }
-            },
-            timestamp: core_1.highResTimestamp,
-            rejectTransaction: (transaction, error) => {
-                // If a node failed to respond in time, it might be sleeping
-                if (this.isMissingNodeACK(transaction, error)) {
-                    if (this.handleMissingNodeACK(transaction))
-                        return;
-                }
-                // 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) => {
-                // 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, {
-                    direction: "outbound",
-                });
-                if (process.env.NODE_ENV !== "test") {
-                    // Enrich error data in case something goes wrong
-                    Sentry.addBreadcrumb({
-                        category: "message",
-                        timestamp: Date.now() / 1000,
-                        type: "debug",
-                        data: {
-                            direction: "outbound",
-                            msgType: msg.type,
-                            functionType: msg.functionType,
-                            name: msg.constructor.name,
-                            nodeId: msg.getNodeId(),
-                            ...msg.toLogEntry(),
-                        },
-                    });
-                }
-            },
-            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.queue = new sorted_list_1.SortedList();
         this._sendThreadIdle = false;
-        this.sendThread.onTransition((state) => {
-            if (state.changed) {
-                this.sendThreadIdle = state.matches("idle");
-            }
-        });
-        // For debugging
-        // this.sendThread.onTransition((state) => {
-        // 	if (state.changed)
-        // 		this.driverLog.print(
-        // 			`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",
-        // 		);
-        // 	}
-        // });
     }
     /** Whether the Send Thread is currently idle */
     get sendThreadIdle() {
@@ -684,7 +564,6 @@ class Driver extends shared_1.TypedEventEmitter {
         this.driverLog.print(`version ${exports.libVersion}`, "info");
         this.driverLog.print("", "info");
         this.driverLog.print("starting driver...");
-        this.sendThread.start();
         // Open the serial port
         if (typeof this.port === "string") {
             if (this.port.startsWith("tcp://")) {
@@ -1077,7 +956,7 @@ class Driver extends shared_1.TypedEventEmitter {
                     if (!node.hasSUCReturnRoute &&
                         node.status !== _Types_1.NodeStatus.Dead) {
                         node.hasSUCReturnRoute =
-                            await this.controller.assignSUCReturnRoute(node.id);
+                            await this.controller.assignSUCReturnRoutes(node.id);
                     }
                 })();
             }
@@ -1203,18 +1082,15 @@ class Driver extends shared_1.TypedEventEmitter {
         this.controllerLog.logNode(node.id, `The node is ${oldStatus === _Types_1.NodeStatus.Unknown ? "" : "now "}awake.`);
         // Make sure to handle the pending messages as quickly as possible
         if (oldStatus === _Types_1.NodeStatus.Asleep) {
-            this.sendThread.send({
-                type: "reduce",
-                reducer: ({ message }) => {
-                    // Ignore messages that are not for this node
-                    if (message.getNodeId() !== node.id)
-                        return { type: "keep" };
-                    // Resolve pings, so we don't need to send them (we know the node is awake)
-                    if ((0, cc_1.messageIsPing)(message))
-                        return { type: "resolve", message: undefined };
-                    // Re-queue all other transactions for this node, so they get added in front of the others
-                    return { type: "requeue" };
-                },
+            this.reduceQueue(({ message }) => {
+                // Ignore messages that are not for this node
+                if (message.getNodeId() !== node.id)
+                    return { type: "keep" };
+                // Resolve pings, so we don't need to send them (we know the node is awake)
+                if ((0, cc_1.messageIsPing)(message))
+                    return { type: "resolve", message: undefined };
+                // Re-queue all other transactions for this node, so they get added in front of the others
+                return { type: "requeue" };
             });
         }
     }
@@ -1555,12 +1431,10 @@ class Driver extends shared_1.TypedEventEmitter {
     }
     /** Checks if there are any pending transactions that match the given predicate */
     hasPendingTransactions(predicate) {
-        const { queue, activeTransactions } = this.sendThread.state.context;
-        if (!!queue.find((t) => predicate(t)))
+        if (!!this.queue.find((t) => predicate(t)))
+            return true;
+        if (this.currentTransaction && predicate(this.currentTransaction)) {
             return true;
-        for (const { transaction } of activeTransactions.values()) {
-            if (predicate(transaction))
-                return true;
         }
         return false;
     }
@@ -1753,7 +1627,7 @@ class Driver extends shared_1.TypedEventEmitter {
         // This is a bit hacky, but what the heck...
         if (!this._enteringBootloader) {
             // Resume sending
-            this.unpauseSendThread();
+            this.unpauseSendQueue();
             // Soft-resetting disables any ongoing inclusion, so we need to reset
             // the state that is tracked in the controller
             this._controller?.setInclusionState(Inclusion_1.InclusionState.Idle);
@@ -1817,11 +1691,11 @@ class Driver extends shared_1.TypedEventEmitter {
         const pollController = async () => {
             try {
                 // And resume sending - this requires us to unpause the send thread
-                this.unpauseSendThread();
+                this.unpauseSendQueue();
                 await this.sendMessage(new GetControllerVersionMessages_1.GetControllerVersionRequest(this), {
                     supportCheck: false,
                 });
-                this.pauseSendThread();
+                this.pauseSendQueue();
                 this.controllerLog.print("Serial API responded");
                 return true;
             }
@@ -1929,8 +1803,9 @@ class Driver extends shared_1.TypedEventEmitter {
         this._destroyPromise = (0, deferred_promise_1.createDeferredPromise)();
         this.driverLog.print("destroying driver instance...");
         // First stop the send thread machine and close the serial port, so nothing happens anymore
-        if (this.sendThread.initialized)
-            this.sendThread.stop();
+        if (this.serialAPIInterpreter?.status === xstate_1.InterpreterStatus.Running) {
+            this.serialAPIInterpreter.stop();
+        }
         if (this.serial != undefined) {
             // Avoid spewing errors if the port was in the middle of receiving something
             this.serial.removeAllListeners();
@@ -1959,7 +1834,6 @@ class Driver extends shared_1.TypedEventEmitter {
         }
         // Remove all timeouts
         for (const timeout of [
-            this.saveToCacheTimer,
             ...this.sendNodeToSleepTimers.values(),
             ...this.retryNodeInterviewTimeouts.values(),
             ...this.autoRefreshNodeValueTimers.values(),
@@ -1967,6 +1841,7 @@ class Driver extends shared_1.TypedEventEmitter {
             this.pollBackgroundRSSITimer,
             ...this.awaitedCommands.map((c) => c.timeout),
             ...this.awaitedMessages.map((m) => m.timeout),
+            ...this.awaitedMessageHeaders.map((h) => h.timeout),
             ...this.awaitedBootloaderChunks.map((b) => b.timeout),
         ]) {
             if (timeout)
@@ -1992,16 +1867,25 @@ class Driver extends shared_1.TypedEventEmitter {
             switch (data) {
                 // single-byte messages - just forward them to the send thread
                 case serial_1.MessageHeaders.ACK: {
-                    this.sendThread.send("ACK");
+                    if (this.serialAPIInterpreter?.status ===
+                        xstate_1.InterpreterStatus.Running) {
+                        this.serialAPIInterpreter.send("ACK");
+                    }
                     return;
                 }
                 case serial_1.MessageHeaders.NAK: {
-                    this.sendThread.send("NAK");
+                    if (this.serialAPIInterpreter?.status ===
+                        xstate_1.InterpreterStatus.Running) {
+                        this.serialAPIInterpreter.send("NAK");
+                    }
                     this._controller?.incrementStatistics("NAK");
                     return;
                 }
                 case serial_1.MessageHeaders.CAN: {
-                    this.sendThread.send("CAN");
+                    if (this.serialAPIInterpreter?.status ===
+                        xstate_1.InterpreterStatus.Running) {
+                        this.serialAPIInterpreter.send("CAN");
+                    }
                     this._controller?.incrementStatistics("CAN");
                     return;
                 }
@@ -2185,7 +2069,16 @@ class Driver extends shared_1.TypedEventEmitter {
                 // We shouldn't throw just because logging a message fails
                 this.driverLog.print(`Logging a message failed: ${(0, shared_1.getErrorMessage)(e)}`);
             }
-            this.sendThread.send({ type: "message", message: msg });
+            // Check if this message is unsolicited by passing it to the Serial API command interpreter if possible
+            if (this.serialAPIInterpreter?.status === xstate_1.InterpreterStatus.Running) {
+                this.serialAPIInterpreter.send({
+                    type: "message",
+                    message: msg,
+                });
+            }
+            else {
+                void this.handleUnsolicitedMessage(msg);
+            }
         }
     }
     /** Handles a decoding error and returns the desired reply to the stick */
@@ -2405,11 +2298,20 @@ class Driver extends shared_1.TypedEventEmitter {
             return false;
         }
         else if (node.canSleep) {
+            if (node.status === _Types_1.NodeStatus.Asleep) {
+                // We already moved the messages to the wakeup queue
+                return true;
+            }
             this.controllerLog.logNode(node.id, `${messagePart1}. 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
+            // There is no longer a reference to the current transaction. If it should be moved to the wakeup queue,
+            // it temporarily needs to be added to the queue again.
+            const handled = this.mayMoveToWakeupQueue(transaction);
+            if (handled) {
+                this.queue.add(transaction);
+            }
+            // Mark the node as asleep. This will move the messages to the wakeup queue
             node.markAsAsleep();
-            return this.mayMoveToWakeupQueue(transaction);
+            return handled;
         }
         else {
             const errorMsg = `${messagePart1}, it is presumed dead`;
@@ -2692,6 +2594,10 @@ ${handlers.length} left`);
             this.controllerLog.logNode(cc.nodeId, `is unknown - discarding received command...`, "warn");
             return true;
         }
+        // CRC16, Transport Service belong outside of Security encapsulation
+        if (cc instanceof cc_1.CRC16CC || cc instanceof cc_1.TransportServiceCC) {
+            return false;
+        }
         if (cc.constructor.name.endsWith("Get") &&
             (cc.frameType === "multicast" || cc.frameType === "broadcast")) {
             this.controllerLog.logNode(cc.nodeId, `received GET-type command via ${cc.frameType} - discarding...`, "warn");
@@ -2797,23 +2703,18 @@ ${handlers.length} left`);
         }
         // It could also be that this is the node's response for a CC that we sent, but where the ACK is delayed
         if ((0, cc_1.isCommandClassContainer)(msg)) {
-            const { activeTransactions } = this.sendThread.state.context;
-            const pendingMessages = [...activeTransactions.values()]
-                .map((t) => t.transaction.getCurrentMessage())
-                .filter((m) => !!m);
-            const msgExpectingUpdate = pendingMessages.find((sentMsg) => {
-                return (sentMsg.expectsNodeUpdate() &&
-                    sentMsg.isExpectedNodeUpdate(msg));
-            });
-            if (msgExpectingUpdate) {
-                // Found a message that is still in progress but expects this message in response.
+            const currentMessage = this.currentTransaction?.getCurrentMessage();
+            if (currentMessage &&
+                currentMessage.expectsNodeUpdate() &&
+                currentMessage.isExpectedNodeUpdate(msg)) {
+                // The message we're currently sending is still in progress but expects this message in response.
                 // Remember the message there.
                 this.controllerLog.logNode(msg.getNodeId(), {
                     message: `received expected response prematurely, remembering it...`,
                     level: "verbose",
                     direction: "inbound",
                 });
-                msgExpectingUpdate.prematureNodeUpdate = msg;
+                currentMessage.prematureNodeUpdate = msg;
                 return;
             }
         }
@@ -3114,6 +3015,252 @@ ${handlers.length} left`);
             this._controller?.incrementStatistics("messagesTX");
         }
     }
+    mayStartNextTransaction() {
+        // We may not send anything if the send thread is paused
+        if (this.queuePaused)
+            return false;
+        const nextTransaction = this.queue.peekStart();
+        // We can't send anything if the queue is empty
+        if (!nextTransaction)
+            return false;
+        const message = nextTransaction.message;
+        const targetNode = message.getNodeUnsafe(this);
+        // The transaction queue is sorted automatically. If the first message is for a sleeping node, all messages in the queue are.
+        // There are a few exceptions:
+        // 1. Pings may be used to determine whether a node is really asleep.
+        // 2. Responses to nonce requests must be sent independent of the node status, because some sleeping nodes may try to send us encrypted messages.
+        //    If we don't send them, they block the send queue
+        // 3. Nodes that can sleep but do not support wakeup: https://github.com/zwave-js/node-zwave-js/discussions/1537
+        //    We need to try and send messages to them even if they are asleep, because we might never hear from them
+        // 	// While the queue is busy, we may not start any transaction, except nonce responses to the node we're currently communicating with
+        // 	if (meta.state.matches("busy")) {
+        // 		if (nextTransaction.priority === MessagePriority.Nonce) {
+        // 			for (const active of ctx.activeTransactions.values()) {
+        // 				if (
+        // 					active.transaction.message.getNodeId() ===
+        // 					nextTransaction.message.getNodeId()
+        // 				) {
+        // 					return true;
+        // 				}
+        // 			}
+        // 		}
+        // 		return false;
+        // 	}
+        // 	Replies to nonce requests and Supervision Get requests must always be allowed
+        if (nextTransaction.priority === core_1.MessagePriority.Nonce ||
+            nextTransaction.priority === core_1.MessagePriority.Supervision) {
+            return true;
+        }
+        // Same for pings
+        if ((0, cc_1.messageIsPing)(message))
+            return true;
+        // Or messages to the controller
+        if (!targetNode)
+            return true;
+        return (targetNode.status !== _Types_1.NodeStatus.Asleep ||
+            (!targetNode.supportsCC(core_1.CommandClasses["Wake Up"]) &&
+                targetNode.interviewStage >= _Types_1.InterviewStage.NodeInfo));
+    }
+    async drainQueue() {
+        // Don't execute more than once at a time
+        if (this.drainQueueBusy)
+            return;
+        this.drainQueueBusy = true;
+        try {
+            while (this.mayStartNextTransaction()) {
+                const transaction = (this.currentTransaction =
+                    this.queue.shift());
+                // We have something to send, so not idle
+                this.sendThreadIdle = false;
+                let error;
+                try {
+                    await this.drainTransactionGenerator(transaction);
+                }
+                catch (e) {
+                    error = e;
+                }
+                finally {
+                    this.currentTransaction = undefined;
+                }
+                // Handle errors after clearing the current transaction.
+                // Otherwise, it will get considered the active transaction and cause an unnecessary SendDataAbort
+                if (error) {
+                    this.rejectTransaction(transaction, error);
+                }
+            }
+        }
+        finally {
+            this.drainQueueBusy = false;
+            this.sendThreadIdle = true;
+        }
+        // Avoid a deadlock when a transaction was added after the advanceQueue call,
+        // but before setting the busy flag back to false
+        if (this.mayStartNextTransaction())
+            this.triggerQueue();
+    }
+    /** Steps through the message generator of a transaction. Throws an error if the transaction should fail. */
+    async drainTransactionGenerator(transaction) {
+        transaction.parts.start();
+        // .self is now guaranteed to be defined
+        let prevResult;
+        // Step through the transaction as long as it gives us a next message
+        while (!(await transaction.parts.self.next(prevResult)).done) {
+            // The .current property of the current transactions's message generator
+            // now contains the next message to send
+            const msg = transaction.getCurrentMessage();
+            // TODO: refactor this nested loop or make it part of executeSerialAPICommand
+            attemptMessage: for (let attemptNumber = 1;; attemptNumber++) {
+                try {
+                    prevResult = await this.executeSerialAPICommand(msg, transaction.stack);
+                    if ((0, SendDataShared_1.isTransmitReport)(prevResult) && !prevResult.isOK()) {
+                        // The node did not acknowledge the command. Convert this into an
+                        // error so it can be handled.
+                        // First throw into the generator, so it can be reset
+                        transaction.parts.self.throw(prevResult).catch(shared_1.noop);
+                        throw new core_1.ZWaveError("The node did not acknowledge the command", core_1.ZWaveErrorCodes.Controller_CallbackNOK, prevResult, transaction.stack);
+                    }
+                    // We got a result - it will be passed to the next iteration
+                    break attemptMessage;
+                }
+                catch (e) {
+                    let delay = 0;
+                    let zwError;
+                    if (!(0, core_1.isZWaveError)(e)) {
+                        zwError = (0, StateMachineShared_1.createMessageDroppedUnexpectedError)(e);
+                    }
+                    else {
+                        if (e.code === core_1.ZWaveErrorCodes.Controller_CommandAborted) {
+                            // This transaction was aborted by the driver due to a controller timeout.
+                            // Rejections, re-queuing etc. have been handled, so just drop it silently and
+                            // continue with the next message
+                            return;
+                        }
+                        else if ((0, SendDataShared_1.isSendData)(msg) &&
+                            e.code === core_1.ZWaveErrorCodes.Controller_Timeout &&
+                            e.context === "callback") {
+                            // If the callback to SendData times out, we need to issue a SendDataAbort
+                            await this.abortSendData();
+                            // Wait a short amount of time so everything can settle
+                            delay = 50;
+                        }
+                        if (this.mayRetrySerialAPICommand(msg, attemptNumber, e.code)) {
+                            // Retry the command
+                            if (delay)
+                                await (0, async_1.wait)(delay, true);
+                            continue attemptMessage;
+                        }
+                        zwError = e;
+                    }
+                    // Sending the command failed, reject the transaction
+                    throw zwError;
+                }
+            }
+        }
+        // This transaction is finished, try the next one
+    }
+    triggerQueue() {
+        process.nextTick(() => this.drainQueue());
+    }
+    mayRetrySerialAPICommand(msg, attemptNumber, errorCode) {
+        if (!(0, SendDataShared_1.isSendData)(msg))
+            return false;
+        if (msg instanceof SendDataMessages_1.SendDataMulticastRequest ||
+            msg instanceof SendDataBridgeMessages_1.SendDataMulticastBridgeRequest) {
+            // Don't try to resend multicast messages if they were already transmitted.
+            // One or more nodes might have already reacted
+            if (errorCode === core_1.ZWaveErrorCodes.Controller_CallbackNOK) {
+                return false;
+            }
+        }
+        return attemptNumber < msg.maxSendAttempts;
+    }
+    /**
+     * Executes a Serial API command and returns or throws the result.
+     * @param transaction The transaction which contains the message to be executed
+     */
+    async executeSerialAPICommand(msg, transactionSource) {
+        const machine = (0, SerialAPICommandMachine_1.createSerialAPICommandMachine)(msg, {
+            sendData: this.writeSerial.bind(this),
+            notifyUnsolicited: (msg) => {
+                void this.handleUnsolicitedMessage(msg);
+            },
+            notifyRetry: (lastError, message, attempts, maxAttempts, delay) => {
+                // Translate the error into a better one
+                let errorReason;
+                switch (lastError) {
+                    case "response timeout":
+                        errorReason = "No response from controller";
+                        this._controller?.incrementStatistics("timeoutResponse");
+                        break;
+                    case "callback timeout":
+                        errorReason = "No callback from controller";
+                        this._controller?.incrementStatistics("timeoutCallback");
+                        break;
+                    case "response NOK":
+                        errorReason =
+                            "The controller response indicated failure";
+                        break;
+                    case "callback NOK":
+                        errorReason =
+                            "The controller callback indicated failure";
+                        break;
+                    case "ACK timeout":
+                        this._controller?.incrementStatistics("timeoutACK");
+                    // fall through
+                    case "CAN":
+                    case "NAK":
+                    default:
+                        errorReason =
+                            "Failed to execute controller command";
+                        break;
+                }
+                this.controllerLog.print(`${errorReason} after ${attempts}/${maxAttempts} attempts. Scheduling next try in ${delay} ms.`, "warn");
+            },
+            timestamp: core_1.highResTimestamp,
+            logOutgoingMessage: (msg) => {
+                this.driverLog.logMessage(msg, {
+                    direction: "outbound",
+                });
+                if (process.env.NODE_ENV !== "test") {
+                    // Enrich error data in case something goes wrong
+                    Sentry.addBreadcrumb({
+                        category: "message",
+                        timestamp: Date.now() / 1000,
+                        type: "debug",
+                        data: {
+                            direction: "outbound",
+                            msgType: msg.type,
+                            functionType: msg.functionType,
+                            name: msg.constructor.name,
+                            nodeId: msg.getNodeId(),
+                            ...msg.toLogEntry(),
+                        },
+                    });
+                }
+            },
+        }, (0, shared_1.pick)(this._options, ["timeouts", "attempts"]));
+        const result = (0, deferred_promise_1.createDeferredPromise)();
+        this.serialAPIInterpreter = (0, xstate_1.interpret)(machine).onDone((evt) => {
+            this.serialAPIInterpreter?.stop();
+            this.serialAPIInterpreter = undefined;
+            const cmdResult = evt.data;
+            if (cmdResult.type === "success") {
+                result.resolve(cmdResult.result);
+            }
+            else if (cmdResult.reason === "callback NOK" &&
+                ((0, SendDataShared_1.isSendData)(msg) || (0, SendDataShared_1.isTransmitReport)(cmdResult.result))) {
+                // For messages that were sent to a node, a NOK callback still contains useful info we need to evaluate
+                // ... so we treat it as a result
+                result.resolve(cmdResult.result);
+            }
+            else {
+                // Convert to a Z-Wave error
+                result.reject((0, StateMachineShared_1.serialAPICommandErrorToZWaveError)(cmdResult.reason, msg, cmdResult.result, transactionSource));
+            }
+        });
+        this.serialAPIInterpreter.start();
+        return result;
+    }
     /**
      * Sends a message to the Z-Wave stick.
      * @param msg The message to send
@@ -3193,22 +3340,20 @@ ${handlers.length} left`);
         transaction.requestWakeUpOnDemand = !!options.requestWakeUpOnDemand;
         transaction.tag = options.tag;
         // And queue it
-        this.sendThread.send({ type: "add", transaction });
+        this.queue.add(transaction);
+        this.triggerQueue();
         // If the transaction should expire, start the timeout
         let expirationTimeout;
         if (options.expire) {
             expirationTimeout = setTimeout(() => {
-                this.sendThread.send({
-                    type: "reduce",
-                    reducer: (t) => {
-                        if (t === transaction)
-                            return {
-                                type: "reject",
-                                message: `The message has expired`,
-                                code: core_1.ZWaveErrorCodes.Controller_MessageExpired,
-                            };
-                        return { type: "keep" };
-                    },
+                this.reduceQueue((t, _source) => {
+                    if (t === transaction)
+                        return {
+                            type: "reject",
+                            message: `The message has expired`,
+                            code: core_1.ZWaveErrorCodes.Controller_MessageExpired,
+                        };
+                    return { type: "keep" };
                 });
             }, options.expire).unref();
         }
@@ -3420,6 +3565,27 @@ ${handlers.length} left`);
         // @ts-expect-error TS doesn't know we've narrowed the return type to match
         return this.sendCommandInternal(command, options);
     }
+    async abortSendData(abortInterpreter = false) {
+        try {
+            const abort = new SendDataMessages_1.SendDataAbort(this);
+            await this.writeSerial(abort.serialize());
+            this.driverLog.logMessage(abort, {
+                direction: "outbound",
+            });
+            // We're bypassing the serial API machine, so we need to wait for the ACK ourselves
+            // This could also cause a NAK or CAN, but we don't really care
+            await this.waitForMessageHeader(() => true, 500).catch(shared_1.noop);
+            // Abort the currently active command machine only if the controller has timed out.
+            // SendData commands we abort early MUST result in the normal callback.
+            if (abortInterpreter &&
+                this.serialAPIInterpreter?.status === xstate_1.InterpreterStatus.Running) {
+                this.serialAPIInterpreter.send("abort");
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
     /**
      * Sends a low-level message like ACK, NAK or CAN immediately
      * @param header The low-level message to send
@@ -3432,6 +3598,40 @@ ${handlers.length} left`);
     async writeSerial(data) {
         return this.serial?.writeAsync(data);
     }
+    /**
+     * Waits until a matching message header is received or a timeout has elapsed. Returns the received message.
+     *
+     * @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 message headers.
+     */
+    waitForMessageHeader(predicate, timeout) {
+        return new Promise((resolve, reject) => {
+            const promise = (0, deferred_promise_1.createDeferredPromise)();
+            const entry = {
+                predicate,
+                handler: (msg) => promise.resolve(msg),
+                timeout: undefined,
+            };
+            this.awaitedMessageHeaders.push(entry);
+            const removeEntry = () => {
+                if (entry.timeout)
+                    clearTimeout(entry.timeout);
+                const index = this.awaitedMessageHeaders.indexOf(entry);
+                if (index !== -1)
+                    this.awaitedMessageHeaders.splice(index, 1);
+            };
+            // When the timeout elapses, remove the wait entry and reject the returned Promise
+            entry.timeout = setTimeout(() => {
+                removeEntry();
+                reject(new core_1.ZWaveError(`Received no matching serial frame within the provided timeout!`, core_1.ZWaveErrorCodes.Controller_Timeout));
+            }, timeout);
+            // When the promise is resolved, remove the wait entry and resolve the returned Promise
+            void promise.then((cc) => {
+                removeEntry();
+                resolve(cc);
+            });
+        });
+    }
     /**
      * Waits until an unsolicited serial message is received or a timeout has elapsed. Returns the received message.
      *
@@ -3524,6 +3724,31 @@ ${handlers.length} left`);
             unregister: removeEntry,
         };
     }
+    rejectTransaction(transaction, error) {
+        // If a node failed to respond in time, it might be sleeping
+        if (this.isMissingNodeACK(transaction, error)) {
+            if (this.handleMissingNodeACK(transaction))
+                return;
+        }
+        // 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) {
+            transaction.parts.self.throw(error).catch(shared_1.noop);
+        }
+        else {
+            transaction.promise.reject(error);
+        }
+    }
+    resolveTransaction(transaction, 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) {
+            transaction.parts.self.throw(result).catch(shared_1.noop);
+        }
+        else {
+            transaction.promise.resolve(result);
+        }
+    }
     /** Checks if a message is allowed to go into the wakeup queue */
     mayMoveToWakeupQueue(transaction) {
         const msg = transaction.message;
@@ -3556,7 +3781,7 @@ ${handlers.length} left`);
             ...requeue,
             tag: "interview",
         };
-        const reducer = (transaction, _source) => {
+        this.reduceQueue((transaction, _source) => {
             const msg = transaction.message;
             if (msg.getNodeId() !== nodeId)
                 return { type: "keep" };
@@ -3567,16 +3792,14 @@ ${handlers.length} left`);
                     ? requeueAndTagAsInterview
                     : requeue
                 : reject;
-        };
-        // Apply the reducer to the send thread
-        this.sendThread.send({ type: "reduce", reducer });
+        });
     }
     /**
      * @internal
      * Rejects all pending transactions that match a predicate and removes them from the send queue
      */
     rejectTransactions(predicate, errorMsg = `The message has been removed from the queue`, errorCode = core_1.ZWaveErrorCodes.Controller_MessageDropped) {
-        const reducer = (transaction) => {
+        this.reduceQueue((transaction, _source) => {
             if (predicate(transaction)) {
                 return {
                     type: "reject",
@@ -3587,9 +3810,7 @@ ${handlers.length} left`);
             else {
                 return { type: "keep" };
             }
-        };
-        // Apply the reducer to the send thread
-        this.sendThread.send({ type: "reduce", reducer });
+        });
     }
     /**
      * @internal
@@ -3599,22 +3820,89 @@ ${handlers.length} left`);
         this.rejectTransactions((t) => t.message.getNodeId() === nodeId, errorMsg, errorCode);
     }
     /**
-     * @internal
-     * Pauses the send thread, avoiding commands to be sent to the controller
+     * Pauses the send queue, avoiding commands to be sent to the controller
      */
-    pauseSendThread() {
-        this.sendThread.send({ type: "pause" });
+    pauseSendQueue() {
+        this.queuePaused = true;
     }
     /**
-     * @internal
-     * Unpauses the send thread, allowing commands to be sent to the controller again
+     * Unpauses the send queue, allowing commands to be sent to the controller again
      */
-    unpauseSendThread() {
-        this.sendThread.send({ type: "unpause" });
+    unpauseSendQueue() {
+        this.queuePaused = false;
+        this.triggerQueue();
+    }
+    reduceQueue(reducer) {
+        const dropQueued = [];
+        let stopActive;
+        const requeue = [];
+        const reduceTransaction = (transaction, source) => {
+            const reducerResult = reducer(transaction, source);
+            switch (reducerResult.type) {
+                case "drop":
+                    if (source === "queue") {
+                        dropQueued.push(transaction);
+                    }
+                    else {
+                        stopActive = transaction;
+                    }
+                    break;
+                case "requeue":
+                    if (reducerResult.priority != undefined) {
+                        transaction.priority = reducerResult.priority;
+                    }
+                    if (reducerResult.tag != undefined) {
+                        transaction.tag = reducerResult.tag;
+                    }
+                    if (source === "active")
+                        stopActive = transaction;
+                    requeue.push(transaction);
+                    break;
+                case "resolve":
+                    this.resolveTransaction(transaction, reducerResult.message);
+                    if (source === "queue") {
+                        dropQueued.push(transaction);
+                    }
+                    else {
+                        stopActive = transaction;
+                    }
+                    break;
+                case "reject":
+                    this.rejectTransaction(transaction, new core_1.ZWaveError(reducerResult.message, reducerResult.code, undefined, transaction.stack));
+                    if (source === "queue") {
+                        dropQueued.push(transaction);
+                    }
+                    else {
+                        stopActive = transaction;
+                    }
+                    break;
+            }
+        };
+        for (const transaction of this.queue) {
+            reduceTransaction(transaction, "queue");
+        }
+        if (this.currentTransaction) {
+            reduceTransaction(this.currentTransaction, "active");
+        }
+        // Now we know what to do with the transactions
+        this.queue.remove(...dropQueued, ...requeue);
+        this.queue.add(...requeue.map((t) => t.clone()));
+        // Abort ongoing SendData messages that should be dropped
+        if ((0, SendDataShared_1.isSendData)(stopActive?.message)) {
+            void this.abortSendData();
+        }
+        // Continue sending
+        this.triggerQueue();
     }
-    /** Re-sorts the send queue */
-    sortSendQueue() {
-        this.sendThread.send("sortQueue");
+    /** @internal */
+    resolvePendingPings(nodeId) {
+        // When a previously sleeping node sends a NIF after a ping was sent to it, but not acknowledged yet,
+        // the node is awake, but the ping would fail. Resolve pending pings, so communication can continue.
+        const msg = this.currentTransaction?.parts.current;
+        if (!!msg && (0, cc_1.messageIsPing)(msg) && msg.getNodeId() === nodeId) {
+            // The pending transaction is a ping. Short-circuit its message generator by throwing something that's not an error
+            this.currentTransaction?.parts.self.throw(undefined).catch(shared_1.noop);
+        }
     }
     /**
      * @internal
@@ -3830,7 +4118,7 @@ ${handlers.length} left`);
             // Avoid re-transmissions etc. communicating with the bootloader
             this.rejectTransactions((_t) => true, "The controller is entering bootloader mode.");
             await this.trySoftReset();
-            this.pauseSendThread();
+            this.pauseSendQueue();
             // Again, just to be very sure
             this.rejectTransactions((_t) => true, "The controller is entering bootloader mode.");
             // It would be nicer to not hardcode the command here, but since we're switching stream parsers
@@ -3880,7 +4168,7 @@ ${handlers.length} left`);
             });
         }
         else {
-            this.unpauseSendThread();
+            this.unpauseSendQueue();
             await this.ensureSerialAPI();
         }
     }