zwave-js 8.7.8 → 8.8.2

package/build/lib/driver/SendThreadMachine.js

@@ -5,71 +5,25 @@ const core_1 = require("@zwave-js/core");
 const sorted_list_1 = require("alcalzone-shared/sorted-list");
 const xstate_1 = require("xstate");
 const actions_1 = require("xstate/lib/actions");
-const ICommandClassContainer_1 = require("../commandclass/ICommandClassContainer");
 const NoOperationCC_1 = require("../commandclass/NoOperationCC");
-const ApplicationCommandRequest_1 = require("../controller/ApplicationCommandRequest");
-const BridgeApplicationCommandRequest_1 = require("../controller/BridgeApplicationCommandRequest");
-const SendDataBridgeMessages_1 = require("../controller/SendDataBridgeMessages");
-const SendDataMessages_1 = require("../controller/SendDataMessages");
-const SendDataShared_1 = require("../controller/SendDataShared");
 const Constants_1 = require("../message/Constants");
 const Types_1 = require("../node/Types");
 const CommandQueueMachine_1 = require("./CommandQueueMachine");
-const StateMachineShared_1 = require("./StateMachineShared");
-// These actions must be assign actions or they will be executed out of order
-const setCurrentTransaction = (0, xstate_1.assign)((ctx) => {
-    const queue = ctx.queue;
-    const next = ctx.queue.shift();
-    return {
-        ...ctx,
-        queue,
-        currentTransaction: next,
-    };
-});
-const deleteCurrentTransaction = (0, xstate_1.assign)((ctx) => ({
-    ...ctx,
-    currentTransaction: undefined,
-}));
-const deleteHandshakeTransaction = (0, xstate_1.assign)((ctx) => ({
-    ...ctx,
-    handshakeTransaction: undefined,
-}));
-const resetSendDataAttempts = (0, xstate_1.assign)({
-    sendDataAttempts: (_) => 0,
-});
-const incrementSendDataAttempts = (0, xstate_1.assign)({
-    sendDataAttempts: (ctx) => ctx.sendDataAttempts + 1,
-});
+const TransactionMachine_1 = require("./TransactionMachine");
+const finalizeTransaction = (0, actions_1.pure)((ctx, evt) => [
+    (0, actions_1.stop)(evt.id),
+    (0, xstate_1.assign)((ctx) => {
+        var _a;
+        // Pause the send thread if necessary
+        const transaction = (_a = ctx.activeTransactions.get(evt.id)) === null || _a === void 0 ? void 0 : _a.transaction;
+        if (transaction === null || transaction === void 0 ? void 0 : transaction.pauseSendThread)
+            ctx.paused = true;
+        // Remove the last reference to the actor
+        ctx.activeTransactions.delete(evt.id);
+        return ctx;
+    }),
+]);
 const forwardToCommandQueue = (0, xstate_1.forwardTo)((ctx) => ctx.commandQueue);
-const currentTransactionIsSendData = (ctx) => { var _a; return (0, SendDataShared_1.isSendData)((_a = ctx.currentTransaction) === null || _a === void 0 ? void 0 : _a.message); };
-const forwardNodeUpdate = (0, actions_1.pure)((ctx, evt) => {
-    return (0, actions_1.raise)({
-        type: "nodeUpdate",
-        result: evt.message,
-    });
-});
-const forwardHandshakeResponse = (0, actions_1.pure)((ctx, evt) => {
-    return (0, actions_1.raise)({
-        type: "handshakeResponse",
-        result: evt.message,
-    });
-});
-const forwardActiveCommandSuccess = (0, actions_1.pure)((ctx, evt) => {
-    return (0, actions_1.raise)({ ...evt, type: "active_command_success" });
-});
-const forwardActiveCommandFailure = (0, actions_1.pure)((ctx, evt) => {
-    return (0, actions_1.raise)({ ...evt, type: "active_command_failure" });
-});
-const forwardActiveCommandError = (0, actions_1.pure)((ctx, evt) => {
-    return (0, actions_1.raise)({ ...evt, type: "active_command_error" });
-});
-const sendCurrentTransactionToCommandQueue = (0, actions_1.send)((ctx) => ({
-    type: "add",
-    transaction: ctx.currentTransaction,
-}), { to: (ctx) => ctx.commandQueue });
-const resetCommandQueue = (0, actions_1.send)("reset", {
-    to: (ctx) => ctx.commandQueue,
-});
 const sortQueue = (0, xstate_1.assign)({
     queue: (ctx) => {
         const queue = ctx.queue;
@@ -80,12 +34,8 @@ const sortQueue = (0, xstate_1.assign)({
         return queue;
     },
 });
-const every = (...guards) => ({
-    type: "every",
-    guards,
-});
 const guards = {
-    maySendFirstMessage: (ctx) => {
+    mayStartTransaction: (ctx, evt, meta) => {
         // We may not send anything if the send thread is paused
         if (ctx.paused)
             return false;
@@ -102,243 +52,96 @@ const guards = {
         //    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
+        // 3.
+        if (nextTransaction.priority === Constants_1.MessagePriority.Handshake)
+            return true;
+        // We may not start any non-handshake transaction while the queue is busy
+        if (meta.state.matches("busy"))
+            return false;
+        // 1./2.
         return (!targetNode ||
             targetNode.status !== Types_1.NodeStatus.Asleep ||
             (!targetNode.supportsCC(core_1.CommandClasses["Wake Up"]) &&
                 targetNode.interviewStage >= Types_1.InterviewStage.NodeInfo) ||
-            (0, NoOperationCC_1.messageIsPing)(message) ||
-            nextTransaction.priority === Constants_1.MessagePriority.Handshake);
-    },
-    requiresNoHandshake: (ctx) => {
-        var _a;
-        const msg = (_a = ctx.currentTransaction) === null || _a === void 0 ? void 0 : _a.message;
-        if (msg instanceof SendDataMessages_1.SendDataRequest ||
-            msg instanceof SendDataBridgeMessages_1.SendDataBridgeRequest) {
-            return !msg.command.requiresPreTransmitHandshake();
-        }
-        return true;
-    },
-    isForActiveTransaction: (ctx, evt, meta) => {
-        return (((meta.state.matches("sending.handshake") ||
-            !!ctx.handshakeTransaction) &&
-            evt.transaction === ctx.handshakeTransaction) ||
-            ((meta.state.matches("sending.execute") ||
-                meta.state.matches("sending.waitForUpdate") ||
-                !!ctx.currentTransaction) &&
-                evt.transaction === ctx.currentTransaction));
-    },
-    expectsNodeUpdate: (ctx) => {
-        var _a;
-        const msg = (_a = ctx.currentTransaction) === null || _a === void 0 ? void 0 : _a.message;
-        if (msg instanceof SendDataMessages_1.SendDataRequest ||
-            msg instanceof SendDataBridgeMessages_1.SendDataBridgeRequest) {
-            return msg.command.expectsCCResponse();
-        }
-        return false;
-    },
-    isExpectedUpdate: (ctx, evt, meta) => {
-        if (!meta.state.matches("sending.waitForUpdate"))
-            return false;
-        const sentMsg = ctx.currentTransaction.message;
-        const receivedMsg = evt.message;
-        return ((receivedMsg instanceof ApplicationCommandRequest_1.ApplicationCommandRequest ||
-            receivedMsg instanceof BridgeApplicationCommandRequest_1.BridgeApplicationCommandRequest) &&
-            sentMsg.command.isExpectedCCResponse(receivedMsg.command));
-    },
-    currentTransactionIsSendData,
-    mayRetry: (ctx, evt) => {
-        const msg = ctx.currentTransaction.message;
-        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 (evt.reason === "callback NOK") {
-                return false;
-            }
-        }
-        return msg.maxSendAttempts > ctx.sendDataAttempts;
-    },
-    /** Whether the message is an outgoing pre-transmit handshake */
-    isPreTransmitHandshakeForCurrentTransaction: (ctx, evt, meta) => {
-        if (!meta.state.matches("sending.handshake"))
-            return false;
-        // Ensure that the current transaction is SendData
-        if (!currentTransactionIsSendData(ctx))
-            return false;
-        const transaction = evt.transaction;
-        if (transaction.priority !== Constants_1.MessagePriority.PreTransmitHandshake)
-            return false;
-        if (transaction.message instanceof SendDataMessages_1.SendDataRequest ||
-            transaction.message instanceof SendDataBridgeMessages_1.SendDataBridgeRequest) {
-            // require the handshake to be for the same node
-            return (transaction.message.command.nodeId ===
-                ctx.currentTransaction.message.command.nodeId);
-        }
-        return false;
-    },
-    isExpectedHandshakeResponse: (ctx, evt, meta) => {
-        if (!ctx.handshakeTransaction)
-            return false;
-        if (!meta.state.matches("sending.handshake.waitForHandshakeResponse"))
-            return false;
-        const sentMsg = ctx.handshakeTransaction.message;
-        const receivedMsg = evt.message;
-        if (!(0, ICommandClassContainer_1.isCommandClassContainer)(receivedMsg))
-            return false;
-        return ((receivedMsg instanceof ApplicationCommandRequest_1.ApplicationCommandRequest ||
-            receivedMsg instanceof BridgeApplicationCommandRequest_1.BridgeApplicationCommandRequest) &&
-            sentMsg.command.isExpectedCCResponse(receivedMsg.command));
-    },
-    /** Whether the message is an outgoing handshake response to the current node*/
-    isHandshakeForCurrentTransaction: (ctx, evt) => {
-        // First ensure that the current transaction is SendData
-        if (!currentTransactionIsSendData(ctx))
-            return false;
-        // Then ensure that the event transaction is also SendData
-        const transaction = evt.transaction;
-        if (transaction.priority !== Constants_1.MessagePriority.Handshake)
-            return false;
-        if (transaction.message instanceof SendDataMessages_1.SendDataRequest ||
-            transaction.message instanceof SendDataBridgeMessages_1.SendDataBridgeRequest) {
-            // require the handshake to be for the same node
-            return (transaction.message.command.nodeId ===
-                ctx.currentTransaction.message.command.nodeId);
-        }
-        return false;
-    },
-    shouldNotKeepCurrentTransaction: (ctx, evt) => {
-        const reducer = evt.reducer;
-        return reducer(ctx.currentTransaction, "current").type !== "keep";
-    },
-    currentTransactionIsPingForNode: (ctx, evt) => {
-        var _a;
-        const msg = (_a = ctx.currentTransaction) === null || _a === void 0 ? void 0 : _a.message;
-        return (!!msg &&
-            (0, NoOperationCC_1.messageIsPing)(msg) &&
-            msg.getNodeId() === evt.nodeId);
+            (0, NoOperationCC_1.messageIsPing)(message));
     },
+    hasNoActiveTransactions: (ctx) => ctx.activeTransactions.size === 0,
 };
-function createMessageDroppedUnexpectedError(original) {
-    const ret = new core_1.ZWaveError(`Message dropped because of an unexpected error: ${original.message}`, core_1.ZWaveErrorCodes.Controller_MessageDropped);
-    if (original.stack)
-        ret.stack = original.stack;
-    return ret;
-}
 function createSendThreadMachine(implementations, params) {
-    const resolveCurrentTransaction = (0, xstate_1.assign)((ctx, evt) => {
-        if (ctx.currentTransaction.pauseSendThread) {
-            ctx.paused = true;
-        }
-        implementations.resolveTransaction(ctx.currentTransaction, evt.result);
-        return ctx;
-    });
-    const resolveCurrentTransactionWithoutMessage = (0, xstate_1.assign)((ctx) => {
-        if (ctx.currentTransaction.pauseSendThread) {
-            ctx.paused = true;
-        }
-        implementations.resolveTransaction(ctx.currentTransaction, undefined);
-        return ctx;
-    });
-    const rejectCurrentTransaction = (0, xstate_1.assign)((ctx, evt) => {
-        implementations.rejectTransaction(ctx.currentTransaction, (0, StateMachineShared_1.sendDataErrorToZWaveError)(evt.reason, ctx.currentTransaction, evt.result));
-        return ctx;
-    });
-    const rejectCurrentTransactionWithError = (0, xstate_1.assign)((ctx, evt) => {
-        implementations.rejectTransaction(ctx.currentTransaction, createMessageDroppedUnexpectedError(evt.error));
-        return ctx;
-    });
-    const rejectCurrentTransactionWithNodeTimeout = (0, xstate_1.assign)((ctx) => {
-        implementations.rejectTransaction(ctx.currentTransaction, (0, StateMachineShared_1.sendDataErrorToZWaveError)("node timeout", ctx.currentTransaction, undefined));
-        return ctx;
-    });
-    const resolveHandshakeTransaction = (0, xstate_1.assign)((ctx, evt) => {
-        implementations.resolveTransaction(ctx.handshakeTransaction, evt.result);
-        return ctx;
-    });
-    const rejectHandshakeTransaction = (0, xstate_1.assign)((ctx, evt) => {
-        implementations.rejectTransaction(ctx.handshakeTransaction, (0, StateMachineShared_1.sendDataErrorToZWaveError)(evt.reason, ctx.handshakeTransaction, evt.result));
-        return ctx;
-    });
-    const rejectHandshakeTransactionWithError = (0, xstate_1.assign)((ctx, evt) => {
-        implementations.rejectTransaction(ctx.handshakeTransaction, createMessageDroppedUnexpectedError(evt.error));
-        return ctx;
-    });
-    const rejectHandshakeTransactionWithNodeTimeout = (0, xstate_1.assign)((ctx) => {
-        const hsTransaction = ctx.handshakeTransaction;
-        if (hsTransaction) {
-            implementations.rejectTransaction(hsTransaction, (0, StateMachineShared_1.sendDataErrorToZWaveError)("node timeout", hsTransaction, undefined));
-        }
-        return ctx;
-    });
-    const resolveEventTransaction = (0, xstate_1.assign)((ctx, evt) => {
-        if (evt.transaction.pauseSendThread) {
-            ctx.paused = true;
-        }
-        implementations.resolveTransaction(evt.transaction, evt.result);
-        return ctx;
-    });
-    const rejectEventTransaction = (0, xstate_1.assign)((ctx, evt) => {
-        implementations.rejectTransaction(evt.transaction, (0, StateMachineShared_1.sendDataErrorToZWaveError)(evt.reason, evt.transaction.message, evt.result));
-        return ctx;
-    });
-    const rejectEventTransactionWithError = (0, xstate_1.assign)((ctx, evt) => {
-        implementations.rejectTransaction(evt.transaction, createMessageDroppedUnexpectedError(evt.error));
-        return ctx;
-    });
     const notifyUnsolicited = (_, evt) => {
         implementations.notifyUnsolicited(evt.message);
     };
-    const reduce = (0, xstate_1.assign)({
-        queue: (ctx, evt) => {
-            const { queue, currentTransaction } = ctx;
-            const drop = [];
-            const requeue = [];
-            const reduceTransaction = (transaction, source) => {
-                const reducerResult = evt.reducer(transaction, source);
-                switch (reducerResult.type) {
-                    case "drop":
-                        drop.push(transaction);
-                        break;
-                    case "requeue":
-                        if (reducerResult.priority != undefined) {
-                            transaction.priority = reducerResult.priority;
-                        }
-                        if (reducerResult.tag != undefined) {
-                            transaction.tag = reducerResult.tag;
-                        }
-                        requeue.push(transaction);
-                        break;
-                    case "resolve":
-                        implementations.resolveTransaction(transaction, reducerResult.message);
-                        drop.push(transaction);
-                        break;
-                    case "reject":
-                        implementations.rejectTransaction(transaction, new core_1.ZWaveError(reducerResult.message, reducerResult.code, undefined, transaction.stack));
-                        drop.push(transaction);
-                        break;
-                }
-            };
-            for (const transaction of queue) {
-                reduceTransaction(transaction, "queue");
+    const reduce = (0, actions_1.pure)((ctx, evt) => {
+        const dropQueued = [];
+        const stopActive = [];
+        const requeue = [];
+        const reduceTransaction = (transaction, source) => {
+            const reducerResult = evt.reducer(transaction, source);
+            switch (reducerResult.type) {
+                case "drop":
+                    (source === "queue" ? dropQueued : stopActive).push(transaction);
+                    break;
+                case "requeue":
+                    if (reducerResult.priority != undefined) {
+                        transaction.priority = reducerResult.priority;
+                    }
+                    if (reducerResult.tag != undefined) {
+                        transaction.tag = reducerResult.tag;
+                    }
+                    if (source === "active")
+                        stopActive.push(transaction);
+                    requeue.push(transaction);
+                    break;
+                case "resolve":
+                    implementations.resolveTransaction(transaction, reducerResult.message);
+                    (source === "queue" ? dropQueued : stopActive).push(transaction);
+                    break;
+                case "reject":
+                    implementations.rejectTransaction(transaction, new core_1.ZWaveError(reducerResult.message, reducerResult.code, undefined, transaction.stack));
+                    (source === "queue" ? dropQueued : stopActive).push(transaction);
+                    break;
             }
-            if (currentTransaction) {
-                reduceTransaction(currentTransaction, "current");
-            }
-            // Now we know what to do with the transactions
-            queue.remove(...drop, ...requeue);
-            queue.add(...requeue);
-            return queue;
-        },
+        };
+        const { queue, activeTransactions } = ctx;
+        for (const transaction of queue) {
+            reduceTransaction(transaction, "queue");
+        }
+        for (const { transaction } of activeTransactions.values()) {
+            reduceTransaction(transaction, "active");
+        }
+        // Now we know what to do with the transactions
+        queue.remove(...dropQueued, ...requeue);
+        queue.add(...requeue);
+        return [
+            (0, xstate_1.assign)((ctx) => ({
+                ...ctx,
+                queue,
+            })),
+            ...stopActive.map((t) => (0, actions_1.send)({ type: "remove", transaction: t }, { to: ctx.commandQueue })),
+        ];
+    });
+    const spawnTransaction = (0, xstate_1.assign)((ctx) => {
+        const newCounter = (ctx.counter + 1) % 0xffffffff;
+        const id = "T" + newCounter.toString(16).padStart(8, "0");
+        const transaction = ctx.queue.shift();
+        const machine = (0, xstate_1.spawn)((0, TransactionMachine_1.createTransactionMachine)(id, transaction, implementations), {
+            name: id,
+        });
+        ctx.activeTransactions.set(id, { machine, transaction });
+        return {
+            ...ctx,
+            counter: newCounter,
+        };
     });
-    const ret = (0, xstate_1.Machine)({
+    const ret = (0, xstate_1.createMachine)({
         id: "SendThread",
         initial: "init",
+        preserveActionOrder: true,
         context: {
             commandQueue: undefined,
             queue: new sorted_list_1.SortedList(),
-            sendDataAttempts: 0,
+            activeTransactions: new Map(),
+            counter: 0,
             paused: false,
         },
         on: {
@@ -349,83 +152,43 @@ function createSendThreadMachine(implementations, params) {
             // messages may come back as "unsolicited", these might be expected updates
             // we need to run them through the serial API machine to avoid mismatches
             message: { actions: forwardToCommandQueue },
-            // resolve/reject any un-interesting transactions if they are done
-            command_success: [
-                // If this notification belongs to an active command, forward it
-                {
-                    cond: "isForActiveTransaction",
-                    actions: forwardActiveCommandSuccess,
-                },
-                // otherwise just resolve it
-                {
-                    actions: resolveEventTransaction,
-                },
-            ],
-            command_failure: [
-                // If this notification belongs to an active command, forward it
-                {
-                    cond: "isForActiveTransaction",
-                    actions: forwardActiveCommandFailure,
-                },
-                // otherwise just reject it
-                {
-                    actions: rejectEventTransaction,
-                },
-            ],
-            command_error: [
-                // If this notification belongs to an active command, forward it
-                {
-                    cond: "isForActiveTransaction",
-                    actions: forwardActiveCommandError,
-                },
-                // otherwise just reject it
-                {
-                    actions: rejectEventTransactionWithError,
-                },
-            ],
-            // handle newly added messages
-            add: [
-                // Trigger outgoing handshakes immediately without queueing
-                {
-                    cond: "isPreTransmitHandshakeForCurrentTransaction",
-                    actions: [
-                        forwardToCommandQueue,
-                        // and inform the state machine when it is the one we've waited for
-                        (0, xstate_1.assign)({
-                            handshakeTransaction: (_, evt) => evt.transaction,
-                        }),
-                    ],
-                },
-                // Forward all handshake messages that could have to do with the current transaction
-                {
-                    cond: "isHandshakeForCurrentTransaction",
-                    actions: forwardToCommandQueue,
-                },
-                {
-                    actions: [
-                        (0, xstate_1.assign)({
-                            queue: (ctx, evt) => {
-                                ctx.queue.add(evt.transaction);
-                                return ctx.queue;
-                            },
-                        }),
+            // Forward NIFs to each transaction machine to resolve potential waiting pings
+            NIF: {
+                actions: (0, actions_1.pure)((ctx, evt) => {
+                    const activeTransactionMachinesForNode = [
+                        ...ctx.activeTransactions.values(),
+                    ]
+                        .filter(({ transaction }) => transaction.message.getNodeId() ===
+                        evt.nodeId)
+                        .map((a) => a.machine.id);
+                    return [
+                        ...activeTransactionMachinesForNode.map((id) => (0, actions_1.send)(evt, { to: id })),
+                        // Sort the send queue and evaluate again whether the next message may be sent
+                        sortQueue,
                         (0, actions_1.raise)("trigger"),
-                    ],
-                },
-            ],
-            unsolicited: [
-                // If a message is returned by the serial API, they might be an expected node update
-                {
-                    cond: "isExpectedHandshakeResponse",
-                    actions: forwardHandshakeResponse,
-                },
-                {
-                    cond: "isExpectedUpdate",
-                    actions: forwardNodeUpdate,
-                },
-                // Return unsolicited messages to the driver
-                { actions: notifyUnsolicited },
-            ],
+                    ];
+                }),
+            },
+            // handle newly added messages
+            add: {
+                actions: [
+                    (0, xstate_1.assign)({
+                        queue: (ctx, evt) => {
+                            ctx.queue.add(evt.transaction);
+                            return ctx.queue;
+                        },
+                    }),
+                    (0, actions_1.raise)("trigger"),
+                ],
+            },
+            reduce: {
+                // Reducing may reorder the queue, so raise a trigger afterwards
+                actions: [reduce, (0, actions_1.raise)("trigger")],
+            },
+            // Return unsolicited messages to the driver
+            unsolicited: {
+                actions: notifyUnsolicited,
+            },
             // Accept external commands to sort the queue
             sortQueue: {
                 actions: [sortQueue, (0, actions_1.raise)("trigger")],
@@ -440,281 +203,63 @@ function createSendThreadMachine(implementations, params) {
                     (0, actions_1.raise)("trigger"),
                 ],
             },
+            // forward events between child machinies
+            forward: {
+                actions: (0, actions_1.send)((_, evt) => ({ ...evt.payload, from: evt.from }), {
+                    to: (_, evt) => evt.to,
+                }),
+            },
+            // Stop transactions when they are done
+            transaction_done: {
+                actions: [finalizeTransaction, (0, actions_1.raise)("trigger")],
+            },
         },
         states: {
             init: {
                 entry: (0, xstate_1.assign)({
                     commandQueue: () => (0, xstate_1.spawn)((0, CommandQueueMachine_1.createCommandQueueMachine)(implementations, params), {
-                        name: "commandQueue",
+                        name: "QUEUE",
                     }),
                 }),
                 // Spawn the command queue when starting the send thread
                 always: "idle",
             },
+            // While idle, any transaction may be started
             idle: {
                 id: "idle",
-                entry: [deleteCurrentTransaction, resetSendDataAttempts],
-                always: [
-                    { cond: "maySendFirstMessage", target: "sending" },
-                ],
-                on: {
-                    trigger: [
-                        {
-                            cond: "maySendFirstMessage",
-                            target: "sending",
-                        },
-                    ],
-                    reduce: {
-                        // Reducing may reorder the queue, so raise a trigger afterwards
-                        actions: [reduce, (0, actions_1.raise)("trigger")],
-                    },
+                always: {
+                    cond: "mayStartTransaction",
+                    // Use the first transaction in the queue as the current one
+                    actions: spawnTransaction,
+                    target: "busy",
                 },
-            },
-            sending: {
-                id: "sending",
-                // Use the first transaction in the queue as the current one
-                entry: setCurrentTransaction,
-                initial: "beforeSend",
                 on: {
-                    NIF: {
-                        // Pings are not retransmitted and won't receive a response if the node wake up after the ping was sent
-                        // Therefore resolve pending pings so the communication may proceed immediately
-                        cond: "currentTransactionIsPingForNode",
-                        actions: [
-                            resolveCurrentTransactionWithoutMessage,
-                            // TODO:
-                            // this.driver.controllerLog.logNode(
-                            // 	node.id,
-                            // 	`Treating the node info as a successful ping...`,
-                            // );
-                        ],
-                        target: "sending.done",
-                        internal: true,
-                    },
-                    reduce: [
-                        // If the current transaction should not be kept, tell the send queue to abort it and go back to idle
-                        {
-                            cond: "shouldNotKeepCurrentTransaction",
-                            actions: [resetCommandQueue, reduce],
-                            target: "sending.done",
-                            internal: true,
-                        },
-                        { actions: reduce },
-                    ],
+                    // On trigger, re-evaluate the conditions to enter "busy"
+                    trigger: { target: "idle" },
                 },
-                states: {
-                    beforeSend: {
-                        entry: [
-                            (0, actions_1.pure)((ctx) => currentTransactionIsSendData(ctx)
-                                ? incrementSendDataAttempts
-                                : undefined),
-                            deleteHandshakeTransaction,
-                        ],
-                        always: [
-                            // Skip this step if no handshake is required
-                            {
-                                cond: "requiresNoHandshake",
-                                target: "execute",
-                            },
-                            // else begin the handshake process
-                            {
-                                target: "handshake",
-                            },
-                        ],
-                    },
-                    handshake: {
-                        // Just send the handshake as a side effect
-                        invoke: {
-                            id: "preTransmitHandshake",
-                            src: "preTransmitHandshake",
-                            onDone: "#sending.execute",
-                        },
-                        initial: "waitForCommandResult",
-                        on: {
-                            handshakeResponse: {
-                                actions: resolveHandshakeTransaction,
-                            },
-                        },
-                        states: {
-                            // After kicking off the command, wait until it is completed
-                            waitForCommandResult: {
-                                on: {
-                                    // On success, start waiting for the handshake response
-                                    active_command_success: "waitForHandshakeResponse",
-                                    active_command_failure: [
-                                        // On failure, retry SendData commands if possible
-                                        {
-                                            cond: "mayRetry",
-                                            actions: rejectHandshakeTransaction,
-                                            target: "#sending.retryWait",
-                                        },
-                                        // Otherwise reject the transaction
-                                        {
-                                            actions: [
-                                                rejectHandshakeTransaction,
-                                                rejectCurrentTransaction,
-                                            ],
-                                            target: "#sending.done",
-                                        },
-                                    ],
-                                    active_command_error: [
-                                        // On failure, retry SendData commands if possible
-                                        {
-                                            cond: "mayRetry",
-                                            actions: rejectHandshakeTransactionWithError,
-                                            target: "#sending.retryWait",
-                                        },
-                                        // Otherwise reject the transaction
-                                        {
-                                            actions: [
-                                                rejectHandshakeTransactionWithError,
-                                                rejectCurrentTransactionWithError,
-                                            ],
-                                            target: "#sending.done",
-                                        },
-                                    ],
-                                },
-                            },
-                            waitForHandshakeResponse: {
-                                after: {
-                                    // If an update times out, retry if possible - otherwise reject the entire transaction
-                                    REPORT_TIMEOUT: [
-                                        // only retry on timeout when configured
-                                        ...(params.attempts
-                                            .retryAfterTransmitReport
-                                            ? [
-                                                {
-                                                    cond: "mayRetry",
-                                                    target: "#sending.retryWait",
-                                                    actions: rejectHandshakeTransactionWithNodeTimeout,
-                                                },
-                                            ]
-                                            : []),
-                                        {
-                                            actions: [
-                                                rejectHandshakeTransactionWithNodeTimeout,
-                                                rejectCurrentTransactionWithNodeTimeout,
-                                            ],
-                                            target: "#sending.done",
-                                        },
-                                    ],
-                                },
-                            },
-                        },
-                    },
-                    execute: {
-                        entry: [
-                            deleteHandshakeTransaction,
-                            sendCurrentTransactionToCommandQueue,
-                        ],
-                        on: {
-                            active_command_success: [
-                                // On success, start waiting for an update
-                                {
-                                    cond: "expectsNodeUpdate",
-                                    target: "waitForUpdate",
-                                },
-                                // or resolve the current transaction if none is required
-                                {
-                                    actions: resolveCurrentTransaction,
-                                    target: "done",
-                                },
-                            ],
-                            active_command_failure: [
-                                // On failure, retry SendData commands if possible
-                                {
-                                    cond: every("currentTransactionIsSendData", "mayRetry"),
-                                    target: "retryWait",
-                                },
-                                // Otherwise reject the transaction
-                                {
-                                    actions: rejectCurrentTransaction,
-                                    target: "done",
-                                },
-                            ],
-                            active_command_error: [
-                                // On failure, retry SendData commands if possible
-                                {
-                                    cond: every("currentTransactionIsSendData", "mayRetry"),
-                                    target: "retryWait",
-                                },
-                                // Otherwise reject the transaction
-                                {
-                                    actions: rejectCurrentTransactionWithError,
-                                    target: "done",
-                                },
-                            ],
-                        },
-                    },
-                    waitForUpdate: {
-                        on: {
-                            nodeUpdate: {
-                                actions: resolveCurrentTransaction,
-                                target: "done",
-                            },
-                            resend: {
-                                // We were asked to resend the pending transaction immediately
-                                // without increasing the retry counter
-                                target: "execute",
-                            },
-                        },
-                        after: {
-                            // If an update times out, retry if possible - otherwise reject the transaction
-                            REPORT_TIMEOUT: [
-                                // only retry on timeout when configured
-                                ...(params.attempts.retryAfterTransmitReport
-                                    ? [
-                                        {
-                                            cond: "mayRetry",
-                                            target: "retryWait",
-                                        },
-                                    ]
-                                    : []),
-                                {
-                                    actions: rejectCurrentTransactionWithNodeTimeout,
-                                    target: "done",
-                                },
-                            ],
-                        },
-                    },
-                    retryWait: {
-                        invoke: {
-                            id: "notify",
-                            src: "notifyRetry",
-                        },
-                        after: {
-                            500: "beforeSend",
-                        },
+            },
+            // While busy, only handshake responses may be sent
+            busy: {
+                id: "busy",
+                always: [
+                    {
+                        cond: "hasNoActiveTransactions",
+                        target: "idle",
                     },
-                    done: {
-                        // Clean up the context after sending
-                        always: {
-                            target: "#idle",
-                            actions: [
-                                deleteCurrentTransaction,
-                                deleteHandshakeTransaction,
-                                resetSendDataAttempts,
-                            ],
-                        },
+                    {
+                        cond: "mayStartTransaction",
+                        // Use the first transaction in the queue as the current one
+                        actions: spawnTransaction,
+                        target: "busy",
                     },
+                ],
+                on: {
+                    // On trigger, re-evaluate the conditions to go spawn transactions or back to idle
+                    trigger: { target: "busy" },
                 },
             },
         },
     }, {
-        services: {
-            preTransmitHandshake: async (ctx) => {
-                // Execute the pre transmit handshake and swallow all errors
-                try {
-                    await ctx.currentTransaction.message.command.preTransmitHandshake();
-                }
-                catch (e) { }
-            },
-            notifyRetry: (ctx) => {
-                var _a;
-                (_a = implementations.notifyRetry) === null || _a === void 0 ? void 0 : _a.call(implementations, "SendData", undefined, ctx.currentTransaction.message, ctx.sendDataAttempts, ctx.currentTransaction.message.maxSendAttempts, 500);
-                return Promise.resolve();
-            },
-        },
         guards: {
             ...guards,
             every: (ctx, event, { cond }) => {
@@ -722,9 +267,6 @@ function createSendThreadMachine(implementations, params) {
                 return keys.every((guardKey) => guards[guardKey](ctx, event, undefined));
             },
         },
-        delays: {
-            REPORT_TIMEOUT: params.timeouts.report,
-        },
     });
     return ret;
 }