zwave-js 15.24.3 → 15.25.0

package/build/cjs/lib/_version.d.ts

@@ -1,3 +1,3 @@
-export declare const PACKAGE_VERSION = "15.24.3";
+export declare const PACKAGE_VERSION = "15.25.0";
 export declare const PACKAGE_NAME = "zwave-js";
 //# sourceMappingURL=_version.d.ts.map

package/build/cjs/lib/_version.js

@@ -22,7 +22,7 @@ __export(version_exports, {
   PACKAGE_VERSION: () => PACKAGE_VERSION
 });
 module.exports = __toCommonJS(version_exports);
-const PACKAGE_VERSION = "15.24.3";
+const PACKAGE_VERSION = "15.25.0";
 const PACKAGE_NAME = "zwave-js";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/build/cjs/lib/_version.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/lib/_version.ts"],
-  "sourcesContent": ["// This file is auto-generated by the codegen maintenance script\nexport const PACKAGE_VERSION = \"15.24.3\";\nexport const PACKAGE_NAME = \"zwave-js\";\n"],
+  "sourcesContent": ["// This file is auto-generated by the codegen maintenance script\nexport const PACKAGE_VERSION = \"15.25.0\";\nexport const PACKAGE_NAME = \"zwave-js\";\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;AAAA;;;;;;AACO,MAAM,kBAAkB;AACxB,MAAM,eAAe;",
   "names": []
 }

package/build/cjs/lib/driver/Driver.d.ts

@@ -416,8 +416,16 @@ export declare class Driver extends TypedEventTarget<DriverEventCallbacks> imple
     private isMissingNodeACK;
     private shouldRequestWakeupOnDemand;
     private partialCCSessions;
-    private getPartialCCSession;
+    /**
+     * Determines the request a new partial CC session is the response to, if any.
+     * This is used to re-request the response when segments are missing.
+     */
+    private findPartialCCSessionRequest;
+    /** Re-requests the response a partial CC session belongs to because segments are missing */
+    private rerequestPartialCCSession;
     private assemblePartialCCs;
+    /** Refreshes the timeouts of awaited messages which a partial message may belong to */
+    private refreshAwaitedMessageTimers;
     private handleTransportServiceCommand;
     private handleUnsolicitedMessage;
     private handleSerialAPIStartedUnexpectedly;

package/build/cjs/lib/driver/Driver.js

@@ -62,6 +62,7 @@ var import_DriverMode = require("./DriverMode.js");
 var import_EndDeviceCLI = require("./EndDeviceCLI.js");
 var import_MessageGenerators = require("./MessageGenerators.js");
 var import_NetworkCache = require("./NetworkCache.js");
+var import_PartialCCSessionManager = require("./PartialCCSessionManager.js");
 var import_Queue = require("./Queue.js");
 var import_SerialAPICommandMachine = require("./SerialAPICommandMachine.js");
 var import_StateMachineShared = require("./StateMachineShared.js");
@@ -117,7 +118,8 @@ const defaultOptions = {
     sendDataJammed: 5,
     nodeInterview: 5,
     smartStartInclusion: 5,
-    firmwareUpdateOTW: 3
+    firmwareUpdateOTW: 3,
+    partialReports: 2
   },
   disableOptimisticValueUpdate: false,
   features: {
@@ -210,6 +212,9 @@ function checkOptions(options) {
   if (options.attempts.firmwareUpdateOTW < 1 || options.attempts.firmwareUpdateOTW > 5) {
     throw new import_core.ZWaveError(`The OTW firmware update attempts must be between 1 and 5!`, import_core.ZWaveErrorCodes.Driver_InvalidOptions);
   }
+  if (options.attempts.partialReports < 0 || options.attempts.partialReports > 3) {
+    throw new import_core.ZWaveError(`The partial reports attempts must be between 0 and 3!`, import_core.ZWaveErrorCodes.Driver_InvalidOptions);
+  }
   if (options.inclusionUserCallbacks) {
     if (!(0, import_typeguards.isObject)(options.inclusionUserCallbacks)) {
       throw new import_core.ZWaveError(`The inclusionUserCallbacks must be an object!`, import_core.ZWaveErrorCodes.Driver_InvalidOptions);
@@ -2218,6 +2223,7 @@ class Driver extends import_shared.TypedEventTarget {
     ]) {
       timeout?.clear();
     }
+    this.partialCCSessions.clear();
   }
   async handleSerialData(serial) {
     try {
@@ -2346,7 +2352,6 @@ class Driver extends import_shared.TypedEventTarget {
     if (!this._controller && (0, import_serialapi.containsCC)(msg))
       return;
     if (msg) {
-      let wasMessageLogged = false;
       if ((0, import_serialapi.isCommandRequest)(msg) && (0, import_serialapi.containsCC)(msg)) {
         if (msg.command instanceof import_cc.SecurityCCCommandEncapsulationNonceGet) {
           const node = this.tryGetNode(msg);
@@ -2359,29 +2364,35 @@ class Driver extends import_shared.TypedEventTarget {
             secondaryTags: ["partial"],
             direction: "inbound"
           });
-          wasMessageLogged = true;
-          void this.handleTransportServiceCommand(msg.command).catch(() => {
+          const reassembled = await this.handleTransportServiceCommand(msg.command);
+          if (!reassembled) {
+            this.refreshAwaitedMessageTimers(msg);
+            return;
+          }
+          msg.command = reassembled;
+        }
+        if (this.isSecurityLevelTooLow(msg.command)) {
+          this.driverLog.logMessage(msg, {
+            direction: "inbound",
+            secondaryTags: ["discarded"]
           });
+          return;
         }
-        if (!await this.assemblePartialCCs(msg)) {
-          for (const entry of this.awaitedMessages) {
-            if (entry.refreshPredicate?.(msg)) {
-              entry.timeout?.refresh();
-            }
-          }
+        const completeMsg = await this.assemblePartialCCs(msg);
+        if (!completeMsg) {
+          this.refreshAwaitedMessageTimers(msg);
           return;
         }
-        if (this.isSecurityLevelTooLow(msg.command) || this.shouldDiscardCC(msg.command)) {
-          if (!wasMessageLogged) {
-            this.driverLog.logMessage(msg, {
-              direction: "inbound",
-              secondaryTags: ["discarded"]
-            });
-          }
+        msg = completeMsg;
+        if (this.shouldDiscardCC(completeMsg.command)) {
+          this.driverLog.logMessage(msg, {
+            direction: "inbound",
+            secondaryTags: ["discarded"]
+          });
           return;
         }
         try {
-          this.persistCCValues(msg.command);
+          this.persistCCValues(completeMsg.command);
         } catch (e) {
           if ((0, import_core.isZWaveError)(e) && e.code === import_core.ZWaveErrorCodes.PacketFormat_InvalidPayload) {
             this.driverLog.print(`dropping CC with invalid values${typeof e.context === "string" ? ` (Reason: ${e.context})` : ""}`, "warn");
@@ -2390,19 +2401,13 @@ class Driver extends import_shared.TypedEventTarget {
             throw e;
           }
         }
-        if ((0, import_cc.isTransportServiceEncapsulation)(msg.command)) {
-          msg.command = msg.command.encapsulated;
-          wasMessageLogged = false;
-        }
       }
-      if (!wasMessageLogged) {
-        try {
-          this.driverLog.logMessage(msg, {
-            direction: "inbound"
-          });
-        } catch (e) {
-          this.driverLog.print(`Logging a message failed: ${(0, import_shared.getErrorMessage)(e)}`);
-        }
+      try {
+        this.driverLog.logMessage(msg, {
+          direction: "inbound"
+        });
+      } catch (e) {
+        this.driverLog.print(`Logging a message failed: ${(0, import_shared.getErrorMessage)(e)}`);
       }
       void this.handleUnsolicitedMessage(msg);
     }
@@ -2766,71 +2771,111 @@ ${(0, import_shared.buffer2hex)(data)}`, "warn");
   shouldRequestWakeupOnDemand(node) {
     return !!node.supportsWakeUpOnDemand && node.status === import_Types2.NodeStatus.Asleep && this.hasPendingTransactions((t) => t.requestWakeUpOnDemand && t.message.getNodeId() === node.id);
   }
-  partialCCSessions = /* @__PURE__ */ new Map();
-  getPartialCCSession(command, createIfMissing) {
-    const sessionId = command.getPartialCCSessionId();
-    if (sessionId) {
-      const partialSessionKey = JSON.stringify({
-        nodeId: command.nodeId,
-        ccId: command.ccId,
-        ccCommand: command.ccCommand,
-        ...sessionId
+  partialCCSessions = new import_PartialCCSessionManager.PartialCCSessionManager({
+    getSegmentTimeout: /* @__PURE__ */ __name(() => this._options.timeouts.report, "getSegmentTimeout"),
+    getMaxReRequestAttempts: /* @__PURE__ */ __name(() => this._options.attempts.partialReports, "getMaxReRequestAttempts"),
+    findRequestCC: /* @__PURE__ */ __name((command) => this.findPartialCCSessionRequest(command), "findRequestCC"),
+    rerequestSession: /* @__PURE__ */ __name((session) => this.rerequestPartialCCSession(session), "rerequestSession"),
+    onSessionLost: /* @__PURE__ */ __name((session) => {
+      this.controllerLog.logNode(session.nodeId, {
+        message: `Dropping incomplete partial CC session`,
+        level: "warn",
+        direction: "inbound"
       });
-      if (createIfMissing && !this.partialCCSessions.has(partialSessionKey)) {
-        this.partialCCSessions.set(partialSessionKey, []);
-      }
-      return {
-        partialSessionKey,
-        session: this.partialCCSessions.get(partialSessionKey)
-      };
+    }, "onSessionLost")
+  });
+  /**
+   * Determines the request a new partial CC session is the response to, if any.
+   * This is used to re-request the response when segments are missing.
+   */
+  findPartialCCSessionRequest(command) {
+    const currentMessage = this.queue.currentTransaction?.getCurrentMessage();
+    if (!currentMessage || !(0, import_serialapi.containsCC)(currentMessage) || currentMessage.getNodeId() !== command.nodeId || !currentMessage.expectsNodeUpdate(this)) {
+      return;
     }
+    const request = (0, import_cc.getInnermostCommandClass)(currentMessage.command);
+    if (!request.isExpectedCCResponse(this, (0, import_cc.getInnermostCommandClass)(command))) {
+      return;
+    }
+    return request;
+  }
+  /** Re-requests the response a partial CC session belongs to because segments are missing */
+  rerequestPartialCCSession(session) {
+    this.refreshAwaitedMessageTimers(session.lastSegmentMsg);
+    this.controllerLog.logNode(session.nodeId, {
+      message: `Some expected reports were not received, requesting the response again...`,
+      level: "warn",
+      direction: "outbound"
+    });
+    void this.sendCommand(session.requestCC, {
+      priority: import_core.MessagePriority.Immediate,
+      maxSendAttempts: 1,
+      ignoreNodeUpdate: true
+    }).catch(import_shared.noop);
   }
   /**
-   * Assembles partial CCs of in a message body. Returns `true` when the message is complete and can be handled further.
-   * If the message expects another partial one, this returns `false`.
+   * Assembles partial CCs in a message body. Returns the message containing the complete
+   * command to continue handling. This is not necessarily the passed message, since responses
+   * may be split into multiple messages.
+   * If the message contains a partial CC and more segments are expected, this returns `undefined`.
    */
   async assemblePartialCCs(msg) {
     let command = msg.command;
     while (true) {
-      const { partialSessionKey, session } = this.getPartialCCSession(command, true) ?? {};
-      if (session) {
-        if (command.expectMoreMessages(session)) {
-          session.push(command);
-          if (!(0, import_cc.isTransportServiceEncapsulation)(msg.command)) {
-            this.driverLog.logMessage(msg, {
-              secondaryTags: ["partial"],
+      const update = this.partialCCSessions.handleCommand(command, msg);
+      if (update?.type === "segment") {
+        if (update.duplicate) {
+          this.controllerLog.logNode(command.nodeId, {
+            message: `Ignoring duplicate partial CC segment:`,
+            level: "debug",
+            direction: "inbound"
+          });
+        }
+        this.driverLog.logMessage(msg, {
+          secondaryTags: ["partial"],
+          direction: "inbound"
+        });
+        return void 0;
+      } else if (update?.type === "complete") {
+        if (update.partials.length > 0) {
+          this.driverLog.logMessage(msg, {
+            secondaryTags: ["partial"],
+            direction: "inbound"
+          });
+        }
+        try {
+          await update.command.mergePartialCCs(update.partials, {
+            ...this.getCCParsingContext(),
+            sourceNodeId: update.command.nodeId,
+            frameType: update.finalMsg.frameType
+          });
+          assertValidCCs(update.finalMsg);
+          if (update.partials.length > 0) {
+            this.controllerLog.logNode(update.command.nodeId, {
+              message: `Assembled partial CC from ${update.partials.length + 1} segments`,
+              level: "debug",
               direction: "inbound"
             });
           }
-          return false;
-        } else {
-          this.partialCCSessions.delete(partialSessionKey);
-          try {
-            await command.mergePartialCCs(session, {
-              ...this.getCCParsingContext(),
-              sourceNodeId: msg.command.nodeId,
-              frameType: msg.frameType
-            });
-            assertValidCCs(msg);
-          } catch (e) {
-            if ((0, import_core.isZWaveError)(e)) {
-              switch (e.code) {
-                case import_core.ZWaveErrorCodes.Deserialization_NotImplemented:
-                case import_core.ZWaveErrorCodes.CC_NotImplemented:
-                  this.driverLog.print(`Dropping message because it could not be deserialized: ${e.message}`, "warn");
-                  return false;
-                case import_core.ZWaveErrorCodes.PacketFormat_InvalidPayload:
-                  this.driverLog.print(`Could not assemble partial CCs because the payload is invalid. Dropping them.`, "warn");
-                  return false;
-                case import_core.ZWaveErrorCodes.Driver_NotReady:
-                  this.driverLog.print(`Could not assemble partial CCs because the driver is not ready yet. Dropping them`, "warn");
-                  return false;
-              }
+        } catch (e) {
+          if ((0, import_core.isZWaveError)(e)) {
+            switch (e.code) {
+              case import_core.ZWaveErrorCodes.Deserialization_NotImplemented:
+              case import_core.ZWaveErrorCodes.CC_NotImplemented:
+                this.driverLog.print(`Dropping message because it could not be deserialized: ${e.message}`, "warn");
+                return void 0;
+              case import_core.ZWaveErrorCodes.PacketFormat_InvalidPayload:
+                this.driverLog.print(`Could not assemble partial CCs because the payload is invalid. Dropping them.`, "warn");
+                return void 0;
+              case import_core.ZWaveErrorCodes.Driver_NotReady:
+                this.driverLog.print(`Could not assemble partial CCs because the driver is not ready yet. Dropping them`, "warn");
+                return void 0;
             }
-            throw e;
           }
+          throw e;
         }
-      } else {
+        msg = update.finalMsg;
+        command = update.command;
       }
       if ((0, import_cc.isEncapsulatingCommandClass)(command)) {
         command = command.encapsulated;
@@ -2838,19 +2883,40 @@ ${(0, import_shared.buffer2hex)(data)}`, "warn");
         break;
       }
     }
-    return true;
+    return msg;
+  }
+  /** Refreshes the timeouts of awaited messages which a partial message may belong to */
+  refreshAwaitedMessageTimers(msg) {
+    for (const entry of this.awaitedMessages) {
+      if (entry.refreshPredicate?.(msg)) {
+        entry.timeout?.refresh();
+      }
+    }
   }
-  /** Is called when a Transport Service command is received */
+  /**
+   * Is called when a Transport Service command is received.
+   * When the command completes a datagram, the reassembled command is returned.
+   */
   async handleTransportServiceCommand(command) {
     const nodeSessions = this.ensureNodeSessions(command.nodeId);
     const missingSegmentTimeout = import_cc.TransportServiceTimeouts.requestMissingSegmentR2;
-    const advanceTransportServiceSession = /* @__PURE__ */ __name(async (session, input) => {
-      const machine = session.machine;
+    const sendSegmentComplete = /* @__PURE__ */ __name(() => {
+      const cc = new import_cc.TransportServiceCCSegmentComplete({
+        nodeId: command.nodeId,
+        sessionId: command.sessionId
+      });
+      void this.sendCommand(cc, {
+        maxSendAttempts: 1,
+        priority: import_core.MessagePriority.Immediate
+      }).catch(import_shared.noop);
+    }, "sendSegmentComplete");
+    const advanceTransportServiceSession = /* @__PURE__ */ __name((session2, input) => {
+      const machine = session2.machine;
       const transition = machine.next(input);
       if (transition) {
         machine.transition(transition.newState);
         if (machine.state.value === "receive") {
-          startMissingSegmentTimeout(session);
+          startMissingSegmentTimeout(session2);
         } else if (machine.state.value === "requestMissing") {
           this.controllerLog.logNode(command.nodeId, {
             message: `Transport Service RX session #${command.sessionId}: Segment with offset ${machine.state.offset} missing - requesting it...`,
@@ -2862,11 +2928,10 @@ ${(0, import_shared.buffer2hex)(data)}`, "warn");
             sessionId: command.sessionId,
             datagramOffset: machine.state.offset
           });
-          await this.sendCommand(cc, {
+          this.sendCommand(cc, {
             maxSendAttempts: 1,
             priority: import_core.MessagePriority.Immediate
-          }).catch(import_shared.noop);
-          startMissingSegmentTimeout(session);
+          }).catch(import_shared.noop).finally(() => startMissingSegmentTimeout(session2));
         } else if (machine.state.value === "failure") {
           this.controllerLog.logNode(command.nodeId, {
             message: `Transport Service RX session #${command.sessionId} failed`,
@@ -2874,42 +2939,39 @@ ${(0, import_shared.buffer2hex)(data)}`, "warn");
             direction: "none"
           });
           nodeSessions.transportService.delete(command.sessionId);
-          if (session.timeout) {
-            clearTimeout(session.timeout);
+          if (session2.timeout) {
+            clearTimeout(session2.timeout);
           }
+        } else if (machine.state.value === "success") {
+          this.controllerLog.logNode(command.nodeId, {
+            message: `Transport Service RX session #${command.sessionId} complete`,
+            level: "debug",
+            direction: "inbound"
+          });
+          if (session2.timeout) {
+            clearTimeout(session2.timeout);
+          }
+          sendSegmentComplete();
+          return "completed";
         }
-      }
-      if (machine.state.value === "success") {
-        this.controllerLog.logNode(command.nodeId, {
-          message: `Transport Service RX session #${command.sessionId} complete`,
-          level: "debug",
-          direction: "inbound"
-        });
-        if (session.timeout) {
-          clearTimeout(session.timeout);
-        }
-        const cc = new import_cc.TransportServiceCCSegmentComplete({
-          nodeId: command.nodeId,
-          sessionId: command.sessionId
-        });
-        await this.sendCommand(cc, {
-          maxSendAttempts: 1,
-          priority: import_core.MessagePriority.Immediate
-        }).catch(import_shared.noop);
+      } else if (machine.state.value === "success") {
+        sendSegmentComplete();
       }
     }, "advanceTransportServiceSession");
-    function startMissingSegmentTimeout(session) {
-      if (session.timeout) {
-        clearTimeout(session.timeout);
+    function startMissingSegmentTimeout(session2) {
+      if (session2.timeout) {
+        clearTimeout(session2.timeout);
       }
-      session.timeout = setTimeout(() => {
-        session.timeout = void 0;
-        void advanceTransportServiceSession(session, {
+      session2.timeout = setTimeout(() => {
+        session2.timeout = void 0;
+        advanceTransportServiceSession(session2, {
           value: "timeout"
         });
       }, missingSegmentTimeout);
     }
     __name(startMissingSegmentTimeout, "startMissingSegmentTimeout");
+    let session;
+    let datagramOffset;
     if (command instanceof import_cc.TransportServiceCCFirstSegment) {
       nodeSessions.transportService.clear();
       this.controllerLog.logNode(command.nodeId, {
@@ -2918,21 +2980,15 @@ ${(0, import_shared.buffer2hex)(data)}`, "warn");
         direction: "inbound"
       });
       const machine = (0, import_TransportServiceMachine.createTransportServiceRXMachine)(command.datagramSize, command.partialDatagram.length);
-      const session = {
-        fragmentSize: command.partialDatagram.length,
-        machine
+      session = {
+        machine,
+        datagram: new import_shared.Bytes(command.datagramSize)
       };
       nodeSessions.transportService.set(command.sessionId, session);
-      startMissingSegmentTimeout(session);
+      datagramOffset = 0;
     } else {
-      const transportSession = nodeSessions.transportService.get(command.sessionId);
-      if (transportSession) {
-        await advanceTransportServiceSession(transportSession, {
-          value: "segment",
-          offset: command.datagramOffset,
-          length: command.partialDatagram.length
-        });
-      } else {
+      session = nodeSessions.transportService.get(command.sessionId);
+      if (!session) {
         const cc = new import_cc.TransportServiceCCSegmentWait({
           nodeId: command.nodeId,
           pendingSegments: 0
@@ -2941,7 +2997,36 @@ ${(0, import_shared.buffer2hex)(data)}`, "warn");
           maxSendAttempts: 1,
           priority: import_core.MessagePriority.Immediate
         }).catch(import_shared.noop);
+        return;
       }
+      datagramOffset = command.datagramOffset;
+    }
+    if (datagramOffset + command.partialDatagram.length > session.datagram.length) {
+      this.controllerLog.logNode(command.nodeId, {
+        message: `Transport Service RX session #${command.sessionId}: Ignoring segment because it is incompatible with the datagram length`,
+        level: "warn",
+        direction: "inbound"
+      });
+      return;
+    }
+    session.datagram.set(command.partialDatagram, datagramOffset);
+    const result = advanceTransportServiceSession(session, {
+      value: "segment",
+      offset: datagramOffset,
+      length: command.partialDatagram.length
+    });
+    if (result !== "completed")
+      return;
+    try {
+      return await import_cc.CommandClass.parse(session.datagram, {
+        ...this.getCCParsingContext(),
+        sourceNodeId: command.nodeId,
+        // Transport Service is only used for singlecast commands
+        frameType: command.frameType ?? "singlecast"
+      });
+    } catch (e) {
+      this.driverLog.print(`Dropping Transport Service datagram because the contained command could not be deserialized: ${(0, import_shared.getErrorMessage)(e)}`, "warn");
+      return;
     }
   }
   /**
@@ -3036,8 +3121,6 @@ ${handlers.length} left`);
       this.controllerLog.logNode(cc.nodeId, `is unknown - discarding received command...`, "warn");
       return true;
     }
-    if (cc instanceof import_cc.TransportServiceCC)
-      return false;
     if (cc instanceof import_cc.CRC16CCCommandEncapsulation) {
       return this.isSecurityLevelTooLow(cc.encapsulated);
     }
@@ -3093,7 +3176,7 @@ ${handlers.length} left`);
       }
     }
     if (requiresSecurity && !isSecure) {
-      this.controllerLog.logNode(cc.nodeId, `command was received at a lower security level than expected - discarding it...`, "warn");
+      this.controllerLog.logNode(cc.nodeId, `command was received at a lower security level than expected - discarding it:`, "warn");
       return true;
     }
     return false;
@@ -4121,6 +4204,9 @@ ${handlers.length} left`);
     if (!!options.reportTimeoutMs) {
       msg.nodeUpdateTimeout = options.reportTimeoutMs;
     }
+    if (options.ignoreNodeUpdate) {
+      msg.ignoreNodeUpdate = true;
+    }
     return msg;
   }
   /**