zwave-js 13.4.0 → 13.6.0

package/build/lib/controller/Controller.js

@@ -22,6 +22,7 @@ const math_1 = require("alcalzone-shared/math");
 const typeguards_1 = require("alcalzone-shared/typeguards");
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const NetworkCache_1 = require("../driver/NetworkCache");
+const Task_1 = require("../driver/Task");
 const DeviceClass_1 = require("../node/DeviceClass");
 const Node_1 = require("../node/Node");
 const VirtualNode_1 = require("../node/VirtualNode");
@@ -431,10 +432,9 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
      * Remembers the indicator values set by another node
      */
     indicatorValues = new Map();
-    _isRebuildingRoutes = false;
     /** Returns whether the routes are currently being rebuilt for one or more nodes. */
     get isRebuildingRoutes() {
-        return this._isRebuildingRoutes;
+        return !!this.driver.scheduler.findTask(utils_1.isRebuildRoutesTask);
     }
     /**
      * Returns a reference to the (virtual) broadcast node, which allows sending commands to all nodes.
@@ -1496,6 +1496,7 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
                 node.lastSeen = new Date();
                 // Resolve active pings that would fail otherwise
                 this.driver.resolvePendingPings(node.id);
+                node.emit("node info received", node);
                 if (node.canSleep
                     && node.supportsCC(core_1.CommandClasses["Wake Up"])) {
                     // In case this is a sleeping node and there are no messages in the queue, the node may go back to sleep very soon
@@ -2875,7 +2876,7 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
      * The information is the same as in the `"rebuild routes progress"` event.
      */
     get rebuildRoutesProgress() {
-        if (!this._isRebuildingRoutes)
+        if (!this.isRebuildingRoutes)
             return undefined;
         return new Map(this._rebuildRoutesProgress);
     }
@@ -2889,10 +2890,11 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
      */
     beginRebuildingRoutes(options = {}) {
         // Don't start the process twice
-        if (this._isRebuildingRoutes)
+        const existingTask = this.driver.scheduler.findTask((t) => t.tag?.id === "rebuild-routes");
+        if (existingTask)
             return false;
-        this._isRebuildingRoutes = true;
         options.includeSleeping ??= true;
+        options.deletePriorityReturnRoutes ??= false;
         this.driver.controllerLog.print(`rebuilding routes${options.includeSleeping ? "" : " for mains-powered nodes"}...`);
         // Reset the progress for all nodes
         this._rebuildRoutesProgress.clear();
@@ -2911,6 +2913,14 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
                 this._rebuildRoutesProgress.set(id, "skipped");
             }
             else if (!options.includeSleeping && node.canSleep) {
+                this.driver.controllerLog.logNode(id, `Skipping route rebuild because the node is sleeping.`);
+                this._rebuildRoutesProgress.set(id, "skipped");
+            }
+            else if (!options.deletePriorityReturnRoutes
+                && (this.getPrioritySUCReturnRouteCached(id)
+                    || Object.keys(this.getPriorityReturnRoutesCached(id))
+                        .length > 0)) {
+                this.driver.controllerLog.logNode(id, `Skipping route rebuild because the node has priority return routes.`);
                 this._rebuildRoutesProgress.set(id, "skipped");
             }
             else {
@@ -2918,14 +2928,15 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
             }
         }
         // Rebuild routes in the background
-        void this.rebuildRoutes(options).catch(() => {
-            /* ignore errors */
-        });
+        void this.rebuildRoutesInternal(options).catch(shared_1.noop);
         // And update the progress once at the start
         this.emit("rebuild routes progress", new Map(this._rebuildRoutesProgress));
         return true;
     }
-    async rebuildRoutes(options) {
+    rebuildRoutesInternal(options) {
+        return this.driver.scheduler.queueTask(this.getRebuildRoutesTask(options));
+    }
+    getRebuildRoutesTask(options) {
         const pendingNodes = new Set([...this._rebuildRoutesProgress]
             .filter(([, status]) => status === "pending")
             .map(([nodeId]) => nodeId));
@@ -2950,74 +2961,100 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
                 }
             }
         };
-        // We work our way outwards from the controller and start with non-sleeping nodes, one by one
-        try {
-            const neighbors = await this.getNodeNeighbors(this._ownNodeId);
-            neighbors.forEach((id) => addTodo(id));
-        }
-        catch {
-            // ignore
-        }
-        const doRebuildRoutes = async (nodeId) => {
-            // await the process for each node and convert errors to a non-successful result
-            const result = await this.rebuildNodeRoutesInternal(nodeId).catch(() => false);
-            if (!this._isRebuildingRoutes)
-                return;
-            // Track the success in a map
-            this._rebuildRoutesProgress.set(nodeId, result ? "done" : "failed");
-            // Notify listeners about the progress
-            this.emit("rebuild routes progress", new Map(this._rebuildRoutesProgress));
-            // Figure out which nodes to do next
-            try {
-                const neighbors = await this.getNodeNeighbors(nodeId);
-                neighbors.forEach((id) => addTodo(id));
-            }
-            catch {
-                // ignore
-            }
+        const self = this;
+        return {
+            priority: Task_1.TaskPriority.Lower,
+            tag: { id: "rebuild-routes" },
+            task: async function* rebuildRoutesTask() {
+                // We work our way outwards from the controller and start with non-sleeping nodes, one by one
+                try {
+                    const neighbors = await self.getNodeNeighbors(self._ownNodeId);
+                    neighbors.forEach((id) => addTodo(id));
+                }
+                catch {
+                    // ignore
+                }
+                yield; // Give the task scheduler time to do something else
+                async function* doRebuildRoutes(nodeId) {
+                    // Await the process for each node and convert errors to a non-successful result
+                    let result;
+                    try {
+                        const node = self.nodes.getOrThrow(nodeId);
+                        result = yield () => self.getRebuildNodeRoutesTask(node);
+                    }
+                    catch {
+                        result = false;
+                    }
+                    // Track the success in a map
+                    self._rebuildRoutesProgress.set(nodeId, result ? "done" : "failed");
+                    // Notify listeners about the progress
+                    self.emit("rebuild routes progress", new Map(self._rebuildRoutesProgress));
+                    yield; // Give the task scheduler time to do something else
+                    // Figure out which nodes to do next
+                    try {
+                        const neighbors = await self.getNodeNeighbors(nodeId);
+                        neighbors.forEach((id) => addTodo(id));
+                    }
+                    catch {
+                        // ignore
+                    }
+                    yield; // Give the task scheduler time to do something else
+                }
+                // First try to rebuild routes for as many nodes as possible one by one
+                while (todoListening.length > 0) {
+                    const nodeId = todoListening.shift();
+                    yield* doRebuildRoutes(nodeId);
+                }
+                // We might end up with a few unconnected listening nodes, try to rebuild routes for them too
+                pendingNodes.forEach((nodeId) => addTodo(nodeId));
+                while (todoListening.length > 0) {
+                    const nodeId = todoListening.shift();
+                    yield* doRebuildRoutes(nodeId);
+                }
+                if (options.includeSleeping) {
+                    // Now do all sleeping nodes at once
+                    self.driver.controllerLog.print("Rebuilding routes for sleeping nodes when they wake up");
+                    const sleepingNodes = todoSleeping.map((nodeId) => self.nodes.get(nodeId)).filter((node) => node != undefined);
+                    const wakeupPromises = new Map(sleepingNodes.map((node) => [
+                        node.id,
+                        node.waitForWakeup().then(() => node),
+                    ]));
+                    // As long as there are sleeping nodes that haven't had their routes rebuilt yet,
+                    // wait for any of them to wake up
+                    while (wakeupPromises.size > 0) {
+                        const wakeUpPromise = Promise.race(wakeupPromises.values());
+                        const wokenUpNode = (yield () => wakeUpPromise);
+                        if (wokenUpNode.status === _Types_1.NodeStatus.Asleep) {
+                            // The node has gone to sleep again since the promise was resolved. Wait again
+                            wakeupPromises.set(wokenUpNode.id, wokenUpNode.waitForWakeup().then(() => wokenUpNode));
+                            continue;
+                        }
+                        // Once the node has woken up, remove it from the list and rebuild its routes
+                        wakeupPromises.delete(wokenUpNode.id);
+                        yield* doRebuildRoutes(wokenUpNode.id);
+                    }
+                }
+                self.driver.controllerLog.print("rebuilding routes completed");
+                self.emit("rebuild routes done", new Map(self._rebuildRoutesProgress));
+                // We're done!
+                self._rebuildRoutesProgress.clear();
+            },
         };
-        // First try to rebuild routes for as many nodes as possible one by one
-        while (todoListening.length > 0) {
-            const nodeId = todoListening.shift();
-            await doRebuildRoutes(nodeId);
-            if (!this._isRebuildingRoutes)
-                return;
-        }
-        // We might end up with a few unconnected listening nodes, try to rebuild routes for them too
-        pendingNodes.forEach((nodeId) => addTodo(nodeId));
-        while (todoListening.length > 0) {
-            const nodeId = todoListening.shift();
-            await doRebuildRoutes(nodeId);
-            if (!this._isRebuildingRoutes)
-                return;
-        }
-        if (options.includeSleeping) {
-            // Now do all sleeping nodes at once
-            this.driver.controllerLog.print("Rebuilding routes for sleeping nodes when they wake up");
-            const tasks = todoSleeping.map((nodeId) => doRebuildRoutes(nodeId));
-            await Promise.all(tasks);
-        }
-        // Only emit the done event when the process wasn't stopped in the meantime
-        if (this._isRebuildingRoutes) {
-            this.driver.controllerLog.print("rebuilding routes completed");
-            this.emit("rebuild routes done", new Map(this._rebuildRoutesProgress));
-        }
-        else {
-            this.driver.controllerLog.print("rebuilding routes aborted");
-        }
-        // We're done!
-        this._isRebuildingRoutes = false;
-        this._rebuildRoutesProgress.clear();
     }
     /**
      * Stops the route rebuilding process. Resolves false if the process was not active, true otherwise.
      */
     stopRebuildingRoutes() {
+        const hasTasks = !!this.driver.scheduler.findTask(utils_1.isRebuildRoutesTask);
         // don't stop it twice
-        if (!this._isRebuildingRoutes)
+        if (!hasTasks)
             return false;
-        this._isRebuildingRoutes = false;
         this.driver.controllerLog.print(`stopping route rebuilding process...`);
+        // Stop all tasks that are part of the route rebuilding process
+        // FIXME: This should be an async function that waits for the task removal
+        void this.driver.scheduler.removeTasks(utils_1.isRebuildRoutesTask).then(() => {
+            this.driver.controllerLog.print("rebuilding routes aborted");
+        });
         // Cancel all transactions that were created by the route rebuilding process
         this.driver.rejectTransactions((t) => t.message instanceof RequestNodeNeighborUpdateMessages_1.RequestNodeNeighborUpdateRequest
             || t.message instanceof DeleteReturnRouteMessages_1.DeleteReturnRouteRequest
@@ -3042,12 +3079,6 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
         if (node.protocol == core_1.Protocols.ZWaveLongRange) {
             throw new core_1.ZWaveError(`Cannot rebuild routes for nodes using Z-Wave Long Range!`, core_1.ZWaveErrorCodes.Argument_Invalid);
         }
-        // Don't start the process twice
-        if (this._isRebuildingRoutes) {
-            this.driver.controllerLog.logNode(nodeId, `Cannot rebuild routes because another rebuilding process is in progress.`);
-            return false;
-        }
-        this._isRebuildingRoutes = true;
         // Figure out if nodes are responsive before attempting to rebuild routes
         if (
         // The node is known to be dead
@@ -3061,139 +3092,159 @@ let ZWaveController = class ZWaveController extends shared_1.TypedEventEmitter {
                 return false;
             }
         }
-        try {
-            return await this.rebuildNodeRoutesInternal(nodeId);
-        }
-        finally {
-            this._isRebuildingRoutes = false;
-        }
+        return this.rebuildNodeRoutesInternal(nodeId);
     }
-    async rebuildNodeRoutesInternal(nodeId) {
+    rebuildNodeRoutesInternal(nodeId) {
         const node = this.nodes.getOrThrow(nodeId);
-        // Keep battery powered nodes awake during the process
-        // and make sure that the flag gets reset at the end
-        const keepAwake = node.keepAwake;
-        try {
-            node.keepAwake = true;
-            this.driver.controllerLog.logNode(nodeId, {
-                message: `Rebuilding routes...`,
-                direction: "none",
-            });
-            // The process consists of four steps, each step is tried up to 5 times before i is considered failed
-            const maxAttempts = 5;
-            // 1. command the node to refresh its neighbor list
-            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-                // If the process was stopped in the meantime, cancel
-                if (!this._isRebuildingRoutes)
-                    return false;
-                this.driver.controllerLog.logNode(nodeId, {
-                    message: `refreshing neighbor list (attempt ${attempt})...`,
-                    direction: "outbound",
+        const task = this.getRebuildNodeRoutesTask(node);
+        if (task instanceof Promise)
+            return task;
+        return this.driver.scheduler.queueTask(task);
+    }
+    getRebuildNodeRoutesTask(node) {
+        // This task should only run once at a time
+        const existingTask = this.driver.scheduler.findTask((t) => t.tag?.id === "rebuild-node-routes" && t.tag.nodeId === node.id);
+        if (existingTask)
+            return existingTask;
+        const self = this;
+        let keepAwake;
+        return {
+            // This task is executed by users and by the network-wide route rebuilding process.
+            priority: Task_1.TaskPriority.Lower,
+            tag: { id: "rebuild-node-routes", nodeId: node.id },
+            task: async function* rebuildNodeRoutesTask() {
+                // Keep battery powered nodes awake during the process
+                keepAwake = node.keepAwake;
+                node.keepAwake = true;
+                if (node.canSleep && node.supportsCC(core_1.CommandClasses["Wake Up"])) {
+                    yield () => node.waitForWakeup();
+                }
+                self.driver.controllerLog.logNode(node.id, {
+                    message: `Rebuilding routes...`,
+                    direction: "none",
                 });
-                try {
-                    const result = await this.discoverNodeNeighbors(nodeId);
-                    if (result) {
-                        this.driver.controllerLog.logNode(nodeId, {
-                            message: "neighbor list refreshed...",
-                            direction: "inbound",
+                // The process consists of four steps, each step is tried up to 5 times before it is considered failed
+                const maxAttempts = 5;
+                // 1. command the node to refresh its neighbor list
+                for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                    yield; // Give the task scheduler time to do something else
+                    self.driver.controllerLog.logNode(node.id, {
+                        message: `refreshing neighbor list (attempt ${attempt})...`,
+                        direction: "outbound",
+                    });
+                    try {
+                        const result = await self.discoverNodeNeighbors(node.id);
+                        if (result) {
+                            self.driver.controllerLog.logNode(node.id, {
+                                message: "neighbor list refreshed...",
+                                direction: "inbound",
+                            });
+                            // this step was successful, continue with the next
+                            break;
+                        }
+                        else {
+                            self.driver.controllerLog.logNode(node.id, {
+                                message: "refreshing neighbor list failed...",
+                                direction: "inbound",
+                                level: "warn",
+                            });
+                        }
+                    }
+                    catch (e) {
+                        self.driver.controllerLog.logNode(node.id, `refreshing neighbor list failed: ${(0, shared_1.getErrorMessage)(e)}`, "warn");
+                    }
+                    if (attempt === maxAttempts) {
+                        self.driver.controllerLog.logNode(node.id, {
+                            message: `rebuilding routes failed: could not update the neighbor list after ${maxAttempts} attempts`,
+                            level: "warn",
+                            direction: "none",
                         });
-                        // this step was successful, continue with the next
+                        return false;
+                    }
+                }
+                yield; // Give the task scheduler time to do something else
+                // 2. re-create the SUC return route, just in case
+                node.hasSUCReturnRoute = await self.assignSUCReturnRoutes(node.id);
+                // 3. delete all return routes to get rid of potential priority return routes
+                for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                    yield; // Give the task scheduler time to do something else
+                    self.driver.controllerLog.logNode(node.id, {
+                        message: `deleting return routes (attempt ${attempt})...`,
+                        direction: "outbound",
+                    });
+                    if (await self.deleteReturnRoutes(node.id)) {
                         break;
                     }
-                    else {
-                        this.driver.controllerLog.logNode(nodeId, {
-                            message: "refreshing neighbor list failed...",
-                            direction: "inbound",
+                    if (attempt === maxAttempts) {
+                        self.driver.controllerLog.logNode(node.id, {
+                            message: `rebuilding routes failed: failed to delete return routes after ${maxAttempts} attempts`,
                             level: "warn",
+                            direction: "none",
                         });
+                        return false;
                     }
                 }
-                catch (e) {
-                    this.driver.controllerLog.logNode(nodeId, `refreshing neighbor list failed: ${(0, shared_1.getErrorMessage)(e)}`, "warn");
-                }
-                if (attempt === maxAttempts) {
-                    this.driver.controllerLog.logNode(nodeId, {
-                        message: `rebuilding routes failed: could not update the neighbor list after ${maxAttempts} attempts`,
-                        level: "warn",
-                        direction: "none",
-                    });
-                    return false;
+                // 4. Assign return routes to all association destinations...
+                let associatedNodes = [];
+                try {
+                    associatedNodes = (0, arrays_1.distinct)((0, shared_1.flatMap)([
+                        ...self.getAssociations({ nodeId: node.id })
+                            .values(),
+                    ], (assocs) => assocs.map((a) => a.nodeId)))
+                        // ...except the controller itself, which was handled by step 2
+                        .filter((id) => id !== self._ownNodeId)
+                        // ...and the node itself
+                        .filter((id) => id !== node.id)
+                        .sort();
                 }
-            }
-            // 2. re-create the SUC return route, just in case
-            node.hasSUCReturnRoute = await this.assignSUCReturnRoutes(nodeId);
-            // 3. delete all return routes to get rid of potential priority return routes
-            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-                this.driver.controllerLog.logNode(nodeId, {
-                    message: `deleting return routes (attempt ${attempt})...`,
-                    direction: "outbound",
-                });
-                if (await this.deleteReturnRoutes(nodeId)) {
-                    break;
+                catch {
+                    // ignore
                 }
-                if (attempt === maxAttempts) {
-                    this.driver.controllerLog.logNode(nodeId, {
-                        message: `rebuilding routes failed: failed to delete return routes after ${maxAttempts} attempts`,
-                        level: "warn",
-                        direction: "none",
+                if (associatedNodes.length > 0) {
+                    self.driver.controllerLog.logNode(node.id, {
+                        message: `assigning return routes to the following nodes:
+	${associatedNodes.join(", ")}`,
+                        direction: "outbound",
                     });
-                    return false;
-                }
-            }
-            // 4. Assign return routes to all association destinations...
-            let associatedNodes = [];
-            try {
-                associatedNodes = (0, arrays_1.distinct)((0, shared_1.flatMap)([...this.getAssociations({ nodeId }).values()], (assocs) => assocs.map((a) => a.nodeId)))
-                    // ...except the controller itself, which was handled by step 2
-                    .filter((id) => id !== this._ownNodeId)
-                    // ...and the node itself
-                    .filter((id) => id !== nodeId)
-                    .sort();
-            }
-            catch {
-                /* ignore */
-            }
-            if (associatedNodes.length > 0) {
-                this.driver.controllerLog.logNode(nodeId, {
-                    message: `assigning return routes to the following nodes:
-${associatedNodes.join(", ")}`,
-                    direction: "outbound",
-                });
-                for (const destinationNodeId of associatedNodes) {
-                    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-                        this.driver.controllerLog.logNode(nodeId, {
-                            message: `assigning return route to node ${destinationNodeId} (attempt ${attempt})...`,
-                            direction: "outbound",
-                        });
-                        if (await this.assignReturnRoutes(nodeId, destinationNodeId)) {
-                            // this step was successful, continue with the next
-                            break;
-                        }
-                        if (attempt === maxAttempts) {
-                            this.driver.controllerLog.logNode(nodeId, {
-                                message: `rebuilding routes failed: failed to assign return route after ${maxAttempts} attempts`,
-                                level: "warn",
-                                direction: "none",
+                    for (const destinationNodeId of associatedNodes) {
+                        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                            yield; // Give the task scheduler time to do something else
+                            self.driver.controllerLog.logNode(node.id, {
+                                message: `assigning return route to node ${destinationNodeId} (attempt ${attempt})...`,
+                                direction: "outbound",
                             });
-                            return false;
+                            if (await self.assignReturnRoutes(node.id, destinationNodeId)) {
+                                // this step was successful, continue with the next
+                                break;
+                            }
+                            if (attempt === maxAttempts) {
+                                self.driver.controllerLog.logNode(node.id, {
+                                    message: `rebuilding routes failed: failed to assign return route after ${maxAttempts} attempts`,
+                                    level: "warn",
+                                    direction: "none",
+                                });
+                                return false;
+                            }
                         }
                     }
                 }
-            }
-            this.driver.controllerLog.logNode(nodeId, {
-                message: `rebuilt routes successfully`,
-                direction: "none",
-            });
-            return true;
-        }
-        finally {
-            node.keepAwake = keepAwake;
-            if (!keepAwake) {
-                setImmediate(() => {
-                    this.driver.debounceSendNodeToSleep(node);
+                self.driver.controllerLog.logNode(node.id, {
+                    message: `rebuilt routes successfully`,
+                    direction: "none",
                 });
-            }
-        }
+                return true;
+            },
+            cleanup: () => {
+                // Make sure that the keepAwake flag gets reset at the end
+                node.keepAwake = keepAwake;
+                if (!keepAwake) {
+                    setImmediate(() => {
+                        this.driver.debounceSendNodeToSleep(node);
+                    });
+                }
+                return Promise.resolve();
+            },
+        };
     }
     /** Configures the given Node to be SUC/SIS or not */
     async configureSUC(nodeId, enableSUC, enableSIS) {
@@ -3325,7 +3376,7 @@ ${associatedNodes.join(", ")}`,
                 if (i !== priorityRouteIndex)
                     assignedRoutes[i] = route;
             }
-            catch (e) {
+            catch {
                 this.driver.controllerLog.logNode(nodeId, {
                     message: `Assigning custom SUC return route #${i} failed`,
                     direction: "outbound",
@@ -3344,7 +3395,7 @@ ${associatedNodes.join(", ")}`,
             try {
                 await this.driver.sendZWaveProtocolCC(cc);
             }
-            catch (e) {
+            catch {
                 this.driver.controllerLog.logNode(nodeId, {
                     message: `Marking custom SUC return route as priority failed`,
                     direction: "outbound",
@@ -3513,7 +3564,7 @@ ${associatedNodes.join(", ")}`,
                 if (i !== priorityRouteIndex)
                     assignedRoutes[i] = route;
             }
-            catch (e) {
+            catch {
                 this.driver.controllerLog.logNode(nodeId, {
                     message: `Assigning custom return route #${i} failed`,
                     direction: "outbound",
@@ -3532,7 +3583,7 @@ ${associatedNodes.join(", ")}`,
             try {
                 await this.driver.sendZWaveProtocolCC(cc);
             }
-            catch (e) {
+            catch {
                 this.driver.controllerLog.logNode(nodeId, {
                     message: `Marking custom return route as priority failed`,
                     direction: "outbound",
@@ -3650,6 +3701,23 @@ ${associatedNodes.join(", ")}`,
     getPriorityReturnRouteCached(nodeId, destinationNodeId) {
         return this.driver.cacheGet(NetworkCache_1.cacheKeys.node(nodeId).priorityReturnRoute(destinationNodeId));
     }
+    /**
+     * For the given node, returns all end node destinations and the priority routes to them.
+     *
+     * **Note:** This is using cached information, since there's no way to query priority routes from a node.
+     * If another controller has assigned routes in the meantime, this information may be out of date.
+     */
+    getPriorityReturnRoutesCached(nodeId) {
+        const ret = {};
+        const routes = this.driver.cacheList(NetworkCache_1.cacheKeys.node(nodeId)._priorityReturnRouteBaseKey);
+        for (const [key, route] of Object.entries(routes)) {
+            const destination = NetworkCache_1.cacheKeyUtils
+                .destinationFromPriorityReturnRouteKey(key);
+            if (destination !== undefined)
+                ret[destination] = route;
+        }
+        return ret;
+    }
     /**
      * Assigns a priority route from an end node to the SUC. This route will always be used for the first transmission attempt.
      * @param nodeId The ID of the end node for which to assign the route
@@ -5475,7 +5543,7 @@ ${associatedNodes.join(", ")}`,
                     try {
                         result = await this.driver.waitForBootloaderChunk((c) => c.type === serial_1.BootloaderChunkType.FlowControl, 1000);
                     }
-                    catch (e) {
+                    catch {
                         this.driver.controllerLog.print("OTW update failed: The bootloader did not acknowledge the start of transfer.", "error");
                         const result = {
                             success: false,
@@ -5550,7 +5618,7 @@ ${associatedNodes.join(", ")}`,
                         this.driver.waitForBootloaderChunk((c) => c.type === serial_1.BootloaderChunkType.Menu, 1000),
                     ]);
                 }
-                catch (e) {
+                catch {
                     this.driver.controllerLog.print("OTW update failed: The bootloader did not acknowledge the end of transfer.", "error");
                     const result = {
                         success: false,