@zwave-js/cc 13.10.1 → 14.0.0-beta.0

package/build/lib/CommandClass.js

@@ -1,104 +1,128 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidCC = exports.CommandClass = void 0;
-exports.gotDeserializationOptions = gotDeserializationOptions;
-exports.assertValidCCs = assertValidCCs;
+exports.InvalidCC = exports.CommandClass = exports.CCRaw = void 0;
+exports.getEffectiveCCVersion = getEffectiveCCVersion;
 const core_1 = require("@zwave-js/core");
-const serial_1 = require("@zwave-js/serial");
 const shared_1 = require("@zwave-js/shared");
 const typeguards_1 = require("alcalzone-shared/typeguards");
 const CommandClassDecorators_1 = require("./CommandClassDecorators");
 const EncapsulatingCommandClass_1 = require("./EncapsulatingCommandClass");
-const ICommandClassContainer_1 = require("./ICommandClassContainer");
 const Values_1 = require("./Values");
-function gotDeserializationOptions(options) {
-    return "data" in options && Buffer.isBuffer(options.data);
+function getEffectiveCCVersion(ctx, cc, defaultVersion) {
+    // For multicast and broadcast CCs, just use the highest implemented version to serialize
+    // Older nodes will ignore the additional fields
+    if (typeof cc.nodeId !== "number"
+        || cc.nodeId === core_1.NODE_ID_BROADCAST
+        || cc.nodeId === core_1.NODE_ID_BROADCAST_LR) {
+        return (0, CommandClassDecorators_1.getImplementedVersion)(cc.ccId);
+    }
+    // For singlecast CCs, set the CC version as high as possible
+    return ctx.getSupportedCCVersion(cc.ccId, cc.nodeId, cc.endpointIndex)
+        || (defaultVersion ?? (0, CommandClassDecorators_1.getImplementedVersion)(cc.ccId));
 }
-function gotCCCommandOptions(options) {
-    return typeof options.nodeId === "number" || (0, typeguards_1.isArray)(options.nodeId);
+class CCRaw {
+    ccId;
+    ccCommand;
+    payload;
+    constructor(ccId, ccCommand, payload) {
+        this.ccId = ccId;
+        this.ccCommand = ccCommand;
+        this.payload = payload;
+    }
+    static parse(data) {
+        const { ccId, bytesRead: ccIdLength } = (0, core_1.parseCCId)(data);
+        // There are so few exceptions that we can handle them here manually
+        if (ccId === core_1.CommandClasses["No Operation"]) {
+            return new CCRaw(ccId, undefined, Buffer.allocUnsafe(0));
+        }
+        let ccCommand = data[ccIdLength];
+        let payload = data.subarray(ccIdLength + 1);
+        if (ccId === core_1.CommandClasses["Transport Service"]) {
+            // Transport Service only uses the higher 5 bits for the command
+            // and re-uses the lower 3 bits of the ccCommand as payload
+            payload = Buffer.concat([
+                Buffer.from([ccCommand & 0b111]),
+                payload,
+            ]);
+            ccCommand = ccCommand & 0b11111_000;
+        }
+        else if (ccId === core_1.CommandClasses["Manufacturer Proprietary"]) {
+            // ManufacturerProprietaryCC has no CC command, so the first
+            // payload byte is stored in ccCommand.
+            payload = Buffer.concat([
+                Buffer.from([ccCommand]),
+                payload,
+            ]);
+            ccCommand = undefined;
+        }
+        return new CCRaw(ccId, ccCommand, payload);
+    }
+    withPayload(payload) {
+        return new CCRaw(this.ccId, this.ccCommand, payload);
+    }
 }
+exports.CCRaw = CCRaw;
 // @publicAPI
 class CommandClass {
     // empty constructor to parse messages
-    constructor(host, options) {
-        this.host = host;
-        // Default to the root endpoint - Inherited classes may override this behavior
-        this.endpointIndex =
-            ("endpoint" in options ? options.endpoint : undefined) ?? 0;
-        // We cannot use @ccValue for non-derived classes, so register interviewComplete as an internal value here
-        // this.registerValue("interviewComplete", { internal: true });
-        if (gotDeserializationOptions(options)) {
-            // For deserialized commands, try to invoke the correct subclass constructor
-            const CCConstructor = (0, CommandClassDecorators_1.getCCConstructor)(CommandClass.getCommandClass(options.data))
-                ?? CommandClass;
-            const ccId = CommandClass.getCommandClass(options.data);
-            const ccCommand = CCConstructor.getCCCommand(options.data);
-            if (ccCommand != undefined) {
-                const CommandConstructor = (0, CommandClassDecorators_1.getCCCommandConstructor)(ccId, ccCommand);
-                if (CommandConstructor
-                    && new.target !== CommandConstructor) {
-                    return new CommandConstructor(host, options);
-                }
-            }
-            // If the constructor is correct or none was found, fall back to normal deserialization
-            if (options.fromEncapsulation) {
-                // Propagate the node ID and endpoint index from the encapsulating CC
-                this.nodeId = options.encapCC.nodeId;
-                if (!this.endpointIndex && options.encapCC.endpointIndex) {
-                    this.endpointIndex = options.encapCC.endpointIndex;
-                }
-                // And remember which CC encapsulates this CC
-                this.encapsulatingCC = options.encapCC;
-            }
-            else {
-                this.nodeId = options.nodeId;
-            }
-            this.frameType = options.frameType;
-            ({
-                ccId: this.ccId,
-                ccCommand: this.ccCommand,
-                payload: this.payload,
-            } = this.deserialize(options.data));
-        }
-        else if (gotCCCommandOptions(options)) {
-            const { nodeId, endpoint = 0, ccId = (0, CommandClassDecorators_1.getCommandClass)(this), ccCommand = (0, CommandClassDecorators_1.getCCCommand)(this), payload = Buffer.allocUnsafe(0), } = options;
-            this.nodeId = nodeId;
-            this.endpointIndex = endpoint;
-            this.ccId = ccId;
-            this.ccCommand = ccCommand;
-            this.payload = payload;
-        }
-        if (this instanceof InvalidCC)
-            return;
-        if (options.origin !== serial_1.MessageOrigin.Host && this.isSinglecast()) {
-            try {
-                // For singlecast CCs, set the CC version as high as possible
-                this.version = this.host.getSafeCCVersion(this.ccId, this.nodeId, this.endpointIndex);
-                // But remember which version the node supports
-                this._knownVersion = this.host.getSupportedCCVersion(this.ccId, this.nodeId, this.endpointIndex);
-            }
-            catch (e) {
-                if ((0, core_1.isZWaveError)(e)
-                    && e.code === core_1.ZWaveErrorCodes.CC_NotImplemented) {
-                    // Someone tried to create a CC that is not implemented. Just set all versions to 0.
-                    this.version = 0;
-                    this._knownVersion = 0;
-                }
-                else {
-                    throw e;
+    constructor(options) {
+        const { nodeId, endpointIndex = 0, ccId = (0, CommandClassDecorators_1.getCommandClass)(this), ccCommand = (0, CommandClassDecorators_1.getCCCommand)(this), payload = Buffer.allocUnsafe(0), } = options;
+        this.nodeId = nodeId;
+        this.endpointIndex = endpointIndex;
+        this.ccId = ccId;
+        this.ccCommand = ccCommand;
+        this.payload = payload;
+    }
+    static parse(data, ctx) {
+        const raw = CCRaw.parse(data);
+        // Find the correct subclass constructor to invoke
+        const CCConstructor = (0, CommandClassDecorators_1.getCCConstructor)(raw.ccId);
+        if (!CCConstructor) {
+            // None -> fall back to the default constructor
+            return CommandClass.from(raw, ctx);
+        }
+        let CommandConstructor;
+        if (raw.ccCommand != undefined) {
+            CommandConstructor = (0, CommandClassDecorators_1.getCCCommandConstructor)(raw.ccId, raw.ccCommand);
+        }
+        // Not every CC has a constructor for its commands. In that case,
+        // call the CC constructor directly
+        try {
+            return (CommandConstructor ?? CCConstructor).from(raw, ctx);
+        }
+        catch (e) {
+            // Indicate invalid payloads with a special CC type
+            if ((0, core_1.isZWaveError)(e)
+                && e.code === core_1.ZWaveErrorCodes.PacketFormat_InvalidPayload) {
+                const ccName = CommandConstructor?.name
+                    ?? `${(0, core_1.getCCName)(raw.ccId)} CC`;
+                // Preserve why the command was invalid
+                let reason;
+                if (typeof e.context === "string"
+                    || (typeof e.context === "number"
+                        && core_1.ZWaveErrorCodes[e.context] != undefined)) {
+                    reason = e.context;
                 }
+                const ret = new InvalidCC({
+                    nodeId: ctx.sourceNodeId,
+                    ccId: raw.ccId,
+                    ccCommand: raw.ccCommand,
+                    ccName,
+                    reason,
+                });
+                return ret;
             }
-            // Send secure commands if necessary
-            this.toggleEncapsulationFlag(core_1.EncapsulationFlags.Security, this.host.isCCSecure(this.ccId, this.nodeId, this.endpointIndex));
-        }
-        else {
-            // For multicast and broadcast CCs, we just use the highest implemented version to serialize
-            // Older nodes will ignore the additional fields
-            this.version = (0, CommandClassDecorators_1.getImplementedVersion)(this.ccId);
-            this._knownVersion = this.version;
+            throw e;
         }
     }
-    host;
+    static from(raw, ctx) {
+        return new this({
+            nodeId: ctx.sourceNodeId,
+            ccId: raw.ccId,
+            ccCommand: raw.ccCommand,
+            payload: raw.payload,
+        });
+    }
     /** This CC's identifier */
     ccId;
     ccCommand;
@@ -109,11 +133,6 @@ class CommandClass {
     nodeId;
     // Work around https://github.com/Microsoft/TypeScript/issues/27555
     payload;
-    /** The version of the command class used */
-    // Work around https://github.com/Microsoft/TypeScript/issues/27555
-    version;
-    /** The version of the CC the node has reported support for */
-    _knownVersion;
     /** Which endpoint of the node this CC belongs to. 0 for the root device. */
     endpointIndex;
     /**
@@ -155,33 +174,11 @@ class CommandClass {
             property: "interviewComplete",
         }, complete);
     }
-    /**
-     * Deserializes a CC from a buffer that contains a serialized CC
-     */
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-    deserialize(data) {
-        const ccId = CommandClass.getCommandClass(data);
-        const ccIdLength = this.isExtended() ? 2 : 1;
-        if (data.length > ccIdLength) {
-            // This is not a NoOp CC (contains command and payload)
-            const ccCommand = data[ccIdLength];
-            const payload = data.subarray(ccIdLength + 1);
-            return {
-                ccId,
-                ccCommand,
-                payload,
-            };
-        }
-        else {
-            // NoOp CC (no command, no payload)
-            const payload = Buffer.allocUnsafe(0);
-            return { ccId, payload };
-        }
-    }
     /**
      * Serializes this CommandClass to be embedded in a message payload or another CC
      */
-    serialize() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    serialize(ctx) {
         // NoOp CCs have no command and no payload
         if (this.ccId === core_1.CommandClasses["No Operation"]) {
             return Buffer.from([this.ccId]);
@@ -202,95 +199,23 @@ class CommandClass {
     prepareRetransmission() {
         // Do nothing by default
     }
-    /** Extracts the CC id from a buffer that contains a serialized CC */
-    static getCommandClass(data) {
-        return (0, core_1.parseCCId)(data).ccId;
-    }
-    /** Extracts the CC command from a buffer that contains a serialized CC  */
-    static getCCCommand(data) {
-        if (data[0] === 0)
-            return undefined; // NoOp
-        const isExtendedCC = data[0] >= 0xf1;
-        return isExtendedCC ? data[2] : data[1];
-    }
-    /**
-     * Retrieves the correct constructor for the CommandClass in the given Buffer.
-     * It is assumed that the buffer only contains the serialized CC. This throws if the CC is not implemented.
-     */
-    static getConstructor(ccData) {
-        const cc = CommandClass.getCommandClass(ccData);
-        const ret = (0, CommandClassDecorators_1.getCCConstructor)(cc);
-        if (!ret) {
-            const ccName = (0, core_1.getCCName)(cc);
-            throw new core_1.ZWaveError(`The command class ${ccName} is not implemented`, core_1.ZWaveErrorCodes.CC_NotImplemented);
-        }
-        return ret;
-    }
-    /**
-     * Creates an instance of the CC that is serialized in the given buffer
-     */
-    static from(host, options) {
-        // Fall back to unspecified command class in case we receive one that is not implemented
-        const ccId = CommandClass.getCommandClass(options.data);
-        const Constructor = (0, CommandClassDecorators_1.getCCConstructor)(ccId) ?? CommandClass;
-        try {
-            return new Constructor(host, options);
-        }
-        catch (e) {
-            // Indicate invalid payloads with a special CC type
-            if ((0, core_1.isZWaveError)(e)
-                && e.code === core_1.ZWaveErrorCodes.PacketFormat_InvalidPayload) {
-                const nodeId = options.fromEncapsulation
-                    ? options.encapCC.nodeId
-                    : options.nodeId;
-                let ccName;
-                const ccId = CommandClass.getCommandClass(options.data);
-                const ccCommand = CommandClass.getCCCommand(options.data);
-                if (ccCommand != undefined) {
-                    ccName = (0, CommandClassDecorators_1.getCCCommandConstructor)(ccId, ccCommand)?.name;
-                }
-                // Fall back to the unspecified CC if the command cannot be determined
-                if (!ccName) {
-                    ccName = `${(0, core_1.getCCName)(ccId)} CC`;
-                }
-                // Preserve why the command was invalid
-                let reason;
-                if (typeof e.context === "string"
-                    || (typeof e.context === "number"
-                        && core_1.ZWaveErrorCodes[e.context] != undefined)) {
-                    reason = e.context;
-                }
-                const ret = new InvalidCC(host, {
-                    nodeId,
-                    ccId,
-                    ccName,
-                    reason,
-                });
-                if (options.fromEncapsulation) {
-                    ret.encapsulatingCC = options.encapCC;
-                }
-                return ret;
-            }
-            throw e;
-        }
-    }
     /**
      * Create an instance of the given CC without checking whether it is supported.
      * If the CC is implemented, this returns an instance of the given CC which is linked to the given endpoint.
      *
      * **INTERNAL:** Applications should not use this directly.
      */
-    static createInstanceUnchecked(host, endpoint, cc) {
+    static createInstanceUnchecked(endpoint, cc) {
         const Constructor = typeof cc === "number" ? (0, CommandClassDecorators_1.getCCConstructor)(cc) : cc;
         if (Constructor) {
-            return new Constructor(host, {
+            return new Constructor({
                 nodeId: endpoint.nodeId,
-                endpoint: endpoint.index,
+                endpointIndex: endpoint.index,
             });
         }
     }
     /** Generates a representation of this CC for the log */
-    toLogEntry(_host) {
+    toLogEntry(_ctx) {
         let tag = this.constructor.name;
         const message = {};
         if (this.constructor === CommandClass) {
@@ -330,20 +255,20 @@ class CommandClass {
     /**
      * Performs the interview procedure for this CC according to SDS14223
      */
-    async interview(_applHost) {
+    async interview(_ctx) {
         // This needs to be overwritten per command class. In the default implementation, don't do anything
     }
     /**
      * Refreshes all dynamic values of this CC
      */
-    async refreshValues(_applHost) {
+    async refreshValues(_ctx) {
         // This needs to be overwritten per command class. In the default implementation, don't do anything
     }
     /**
      * Checks if the CC values need to be manually refreshed.
      * This should be called regularly and when sleeping nodes wake up
      */
-    shouldRefreshValues(_applHost) {
+    shouldRefreshValues(_ctx) {
         // This needs to be overwritten per command class.
         // In the default implementation, don't require a refresh
         return false;
@@ -368,7 +293,7 @@ class CommandClass {
      * Maps a BasicCC value to a more specific CC implementation. Returns true if the value was mapped, false otherwise.
      * @param _value The value of the received BasicCC
      */
-    setMappedBasicValue(_applHost, _value) {
+    setMappedBasicValue(_ctx, _value) {
         // By default, don't map
         return false;
     }
@@ -401,18 +326,18 @@ class CommandClass {
     /**
      * Returns the node this CC is linked to. Throws if the controller is not yet ready.
      */
-    getNode(applHost) {
+    getNode(ctx) {
         if (this.isSinglecast()) {
-            return applHost.nodes.get(this.nodeId);
+            return ctx.getNode(this.nodeId);
         }
     }
     /**
      * @internal
      * Returns the node this CC is linked to (or undefined if the node doesn't exist)
      */
-    getNodeUnsafe(applHost) {
+    tryGetNode(ctx) {
         try {
-            return this.getNode(applHost);
+            return this.getNode(ctx);
         }
         catch (e) {
             // This was expected
@@ -423,14 +348,14 @@ class CommandClass {
             throw e;
         }
     }
-    getEndpoint(applHost) {
-        return this.getNode(applHost)?.getEndpoint(this.endpointIndex);
+    getEndpoint(ctx) {
+        return this.getNode(ctx)?.getEndpoint(this.endpointIndex);
     }
     /** Returns the value DB for this CC's node */
-    getValueDB(host) {
+    getValueDB(ctx) {
         if (this.isSinglecast()) {
             try {
-                return host.getValueDB(this.nodeId);
+                return ctx.getValueDB(this.nodeId);
             }
             catch {
                 throw new core_1.ZWaveError("The node for this CC does not exist or the driver is not ready yet", core_1.ZWaveErrorCodes.Driver_NotReady);
@@ -443,8 +368,8 @@ class CommandClass {
      * The endpoint index of the current CC instance is automatically taken into account.
      * @param meta Will be used in place of the predefined metadata when given
      */
-    ensureMetadata(host, ccValue, meta) {
-        const valueDB = this.getValueDB(host);
+    ensureMetadata(ctx, ccValue, meta) {
+        const valueDB = this.getValueDB(ctx);
         const valueId = ccValue.endpoint(this.endpointIndex);
         if (!valueDB.hasMetadata(valueId)) {
             valueDB.setMetadata(valueId, meta ?? ccValue.meta);
@@ -454,8 +379,8 @@ class CommandClass {
      * Removes the metadata for the given CC value from the value DB.
      * The endpoint index of the current CC instance is automatically taken into account.
      */
-    removeMetadata(host, ccValue) {
-        const valueDB = this.getValueDB(host);
+    removeMetadata(ctx, ccValue) {
+        const valueDB = this.getValueDB(ctx);
         const valueId = ccValue.endpoint(this.endpointIndex);
         valueDB.setMetadata(valueId, undefined);
     }
@@ -464,8 +389,8 @@ class CommandClass {
      * The endpoint index of the current CC instance is automatically taken into account.
      * @param meta Will be used in place of the predefined metadata when given
      */
-    setMetadata(host, ccValue, meta) {
-        const valueDB = this.getValueDB(host);
+    setMetadata(ctx, ccValue, meta) {
+        const valueDB = this.getValueDB(ctx);
         const valueId = ccValue.endpoint(this.endpointIndex);
         valueDB.setMetadata(valueId, meta ?? ccValue.meta);
     }
@@ -473,8 +398,8 @@ class CommandClass {
      * Reads the metadata for the given CC value from the Value DB.
      * The endpoint index of the current CC instance is automatically taken into account.
      */
-    getMetadata(host, ccValue) {
-        const valueDB = this.getValueDB(host);
+    getMetadata(ctx, ccValue) {
+        const valueDB = this.getValueDB(ctx);
         const valueId = ccValue.endpoint(this.endpointIndex);
         return valueDB.getMetadata(valueId);
     }
@@ -482,8 +407,8 @@ class CommandClass {
      * Stores the given value under the value ID for the given CC value in the value DB.
      * The endpoint index of the current CC instance is automatically taken into account.
      */
-    setValue(host, ccValue, value) {
-        const valueDB = this.getValueDB(host);
+    setValue(ctx, ccValue, value) {
+        const valueDB = this.getValueDB(ctx);
         const valueId = ccValue.endpoint(this.endpointIndex);
         valueDB.setValue(valueId, value);
     }
@@ -491,8 +416,8 @@ class CommandClass {
      * Removes the value for the given CC value from the value DB.
      * The endpoint index of the current CC instance is automatically taken into account.
      */
-    removeValue(host, ccValue) {
-        const valueDB = this.getValueDB(host);
+    removeValue(ctx, ccValue) {
+        const valueDB = this.getValueDB(ctx);
         const valueId = ccValue.endpoint(this.endpointIndex);
         valueDB.removeValue(valueId);
     }
@@ -500,8 +425,8 @@ class CommandClass {
      * Reads the value stored for the value ID of the given CC value from the value DB.
      * The endpoint index of the current CC instance is automatically taken into account.
      */
-    getValue(host, ccValue) {
-        const valueDB = this.getValueDB(host);
+    getValue(ctx, ccValue) {
+        const valueDB = this.getValueDB(ctx);
         const valueId = ccValue.endpoint(this.endpointIndex);
         return valueDB.getValue(valueId);
     }
@@ -509,8 +434,8 @@ class CommandClass {
      * Reads when the value stored for the value ID of the given CC value was last updated in the value DB.
      * The endpoint index of the current CC instance is automatically taken into account.
      */
-    getValueTimestamp(host, ccValue) {
-        const valueDB = this.getValueDB(host);
+    getValueTimestamp(ctx, ccValue) {
+        const valueDB = this.getValueDB(ctx);
         const valueId = ccValue.endpoint(this.endpointIndex);
         return valueDB.getTimestamp(valueId);
     }
@@ -534,13 +459,17 @@ class CommandClass {
             ...properties,
         }));
     }
-    shouldAutoCreateValue(applHost, value) {
+    shouldAutoCreateValue(ctx, value) {
         return (value.options.autoCreate === true
             || (typeof value.options.autoCreate === "function"
-                && value.options.autoCreate(applHost, this.getEndpoint(applHost))));
+                && value.options.autoCreate(ctx, {
+                    virtual: false,
+                    nodeId: this.nodeId,
+                    index: this.endpointIndex,
+                })));
     }
     /** Returns a list of all value names that are defined for this CommandClass */
-    getDefinedValueIDs(applHost, includeInternal = false) {
+    getDefinedValueIDs(ctx, includeInternal = false) {
         // In order to compare value ids, we need them to be strings
         const ret = new Map();
         const addValueId = (property, propertyKey) => {
@@ -555,12 +484,21 @@ class CommandClass {
                 ret.set(dbKey, valueId);
         };
         // Return all value IDs for this CC...
-        const valueDB = this.getValueDB(applHost);
+        const valueDB = this.getValueDB(ctx);
         // ...which either have metadata or a value
         const existingValueIds = [
             ...valueDB.getValues(this.ccId),
             ...valueDB.getAllMetadata(this.ccId),
         ];
+        // To determine which value IDs to expose, we need to know the CC version
+        // that we're doing this for
+        const supportedVersion = typeof this.nodeId === "number"
+            && this.nodeId !== core_1.NODE_ID_BROADCAST
+            && this.nodeId !== core_1.NODE_ID_BROADCAST_LR
+            // On singlecast CCs, use the version the node reported support for,
+            ? ctx.getSupportedCCVersion(this.ccId, this.nodeId, this.endpointIndex)
+            // on multicast/broadcast, use the highest version we implement
+            : (0, CommandClassDecorators_1.getImplementedVersion)(this.ccId);
         // ...or which are statically defined using @ccValues(...)
         for (const value of Object.values((0, CommandClassDecorators_1.getCCValues)(this) ?? {})) {
             // Skip dynamic CC values - they need a specific subclass instance to be evaluated
@@ -568,14 +506,14 @@ class CommandClass {
                 continue;
             // Skip those values that are only supported in higher versions of the CC
             if (value.options.minVersion != undefined
-                && value.options.minVersion > this._knownVersion) {
+                && value.options.minVersion > supportedVersion) {
                 continue;
             }
             // Skip internal values
             if (value.options.internal && !includeInternal)
                 continue;
             // And determine if this value should be automatically "created"
-            if (!this.shouldAutoCreateValue(applHost, value))
+            if (!this.shouldAutoCreateValue(ctx, value))
                 continue;
             existingValueIds.push(value.endpoint(this.endpointIndex));
         }
@@ -619,21 +557,26 @@ class CommandClass {
      * Persists all values for this CC instance into the value DB which are annotated with @ccValue.
      * Returns `true` if the process succeeded, `false` if the value DB cannot be accessed.
      */
-    persistValues(applHost) {
+    persistValues(ctx) {
         let valueDB;
         try {
-            valueDB = this.getValueDB(applHost);
+            valueDB = this.getValueDB(ctx);
         }
         catch {
             return false;
         }
+        // To determine which value IDs to expose, we need to know the CC version
+        // that we're doing this for
+        const supportedVersion = ctx.getSupportedCCVersion(this.ccId, 
+        // Values are only persisted for singlecast, so we know nodeId is a number
+        this.nodeId, this.endpointIndex) || 1;
         // Get all properties of this CC which are annotated with a @ccValue decorator and store them.
         for (const [prop, _value] of (0, CommandClassDecorators_1.getCCValueProperties)(this)) {
             // Evaluate dynamic CC values first
             const value = typeof _value === "function" ? _value(this) : _value;
             // Skip those values that are only supported in higher versions of the CC
             if (value.options.minVersion != undefined
-                && value.options.minVersion > this.version) {
+                && value.options.minVersion > supportedVersion) {
                 continue;
             }
             const valueId = value.endpoint(this.endpointIndex);
@@ -644,8 +587,8 @@ class CommandClass {
                 && (sourceValue != undefined
                     // ... or if we know which CC version the node supports
                     // and the value may be automatically created
-                    || (this._knownVersion >= value.options.minVersion
-                        && this.shouldAutoCreateValue(applHost, value)));
+                    || (supportedVersion >= value.options.minVersion
+                        && this.shouldAutoCreateValue(ctx, value)));
             if (createMetadata && !valueDB.hasMetadata(valueId)) {
                 valueDB.setMetadata(valueId, value.meta);
             }
@@ -674,8 +617,7 @@ class CommandClass {
         return false; // By default, all CCs are monolithic
     }
     /** Include previously received partial responses into a final CC */
-    /* istanbul ignore next */
-    mergePartialCCs(_applHost, _partials) {
+    mergePartialCCs(_partials, _ctx) {
         // This is highly CC dependent
         // Overwrite this in derived classes, by default do nothing
     }
@@ -742,7 +684,7 @@ class CommandClass {
      * @param property The property identifier that should be translated
      * @param _propertyKey The (optional) property key the translated name may depend on
      */
-    translateProperty(_applHost, property, _propertyKey) {
+    translateProperty(_ctx, property, _propertyKey) {
         // Overwrite this in derived classes, by default just return the property key
         return property.toString();
     }
@@ -751,7 +693,7 @@ class CommandClass {
      * @param _property The property the key in question belongs to
      * @param propertyKey The property key for which the speaking name should be retrieved
      */
-    translatePropertyKey(_applHost, _property, propertyKey) {
+    translatePropertyKey(_ctx, _property, propertyKey) {
         // Overwrite this in derived classes, by default just return the property key
         return propertyKey.toString();
     }
@@ -818,8 +760,8 @@ class CommandClass {
 }
 exports.CommandClass = CommandClass;
 class InvalidCC extends CommandClass {
-    constructor(host, options) {
-        super(host, options);
+    constructor(options) {
+        super(options);
         this._ccName = options.ccName;
         // Numeric reasons are used internally to communicate problems with a CC
         // without ignoring them entirely
@@ -830,7 +772,7 @@ class InvalidCC extends CommandClass {
         return this._ccName;
     }
     reason;
-    toLogEntry(_host) {
+    toLogEntry(_ctx) {
         return {
             tags: [this.ccName, "INVALID"],
             message: this.reason != undefined
@@ -844,18 +786,4 @@ class InvalidCC extends CommandClass {
     }
 }
 exports.InvalidCC = InvalidCC;
-/** @publicAPI */
-function assertValidCCs(container) {
-    if (container.command instanceof InvalidCC) {
-        if (typeof container.command.reason === "number") {
-            throw new core_1.ZWaveError("The message payload failed validation!", container.command.reason);
-        }
-        else {
-            throw new core_1.ZWaveError("The message payload is invalid!", core_1.ZWaveErrorCodes.PacketFormat_InvalidPayload, container.command.reason);
-        }
-    }
-    else if ((0, ICommandClassContainer_1.isCommandClassContainer)(container.command)) {
-        assertValidCCs(container.command);
-    }
-}
 //# sourceMappingURL=CommandClass.js.map