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

package/build/cc/MultiChannelCC.js

@@ -5,6 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var MultiChannelCCEndPointReport_1, MultiChannelCCCapabilityReport_1, MultiChannelCCCapabilityGet_1, MultiChannelCCEndPointFindReport_1, MultiChannelCCEndPointFind_1, MultiChannelCCAggregatedMembersReport_1, MultiChannelCCCommandEncapsulation_1, MultiChannelCCV1Report_1, MultiChannelCCV1CommandEncapsulation_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultiChannelCCV1CommandEncapsulation = exports.MultiChannelCCV1Get = exports.MultiChannelCCV1Report = exports.MultiChannelCCCommandEncapsulation = exports.MultiChannelCCAggregatedMembersGet = exports.MultiChannelCCAggregatedMembersReport = exports.MultiChannelCCEndPointFind = exports.MultiChannelCCEndPointFindReport = exports.MultiChannelCCCapabilityGet = exports.MultiChannelCCCapabilityReport = exports.MultiChannelCCEndPointGet = exports.MultiChannelCCEndPointReport = exports.MultiChannelCC = exports.MultiChannelCCAPI = exports.MultiChannelCCValues = void 0;
 function __assertType(argName, typeName, boundHasError) {
@@ -24,6 +25,7 @@ const arrays_1 = require("alcalzone-shared/arrays");
 const API_1 = require("../lib/API");
 const CommandClass_1 = require("../lib/CommandClass");
 const CommandClassDecorators_1 = require("../lib/CommandClassDecorators");
+const EncapsulatingCommandClass_1 = require("../lib/EncapsulatingCommandClass");
 const Values_1 = require("../lib/Values");
 const _Types_1 = require("../lib/_Types");
 // TODO: Handle removal reports of dynamic endpoints
@@ -61,13 +63,13 @@ exports.MultiChannelCCValues = Object.freeze({
  * Many devices unnecessarily use endpoints when they could (or do) provide all functionality via the root device.
  * This function gives an estimate if this is the case (i.e. all endpoints have a different device class)
  */
-function areEndpointsUnnecessary(applHost, node, endpointIndizes) {
+function areEndpointsUnnecessary(ctx, nodeId, endpointIndizes) {
     // Gather all device classes
     const deviceClasses = new Map();
     for (const endpoint of endpointIndizes) {
         const devClassValueId = exports.MultiChannelCCValues.endpointDeviceClass
             .endpoint(endpoint);
-        const deviceClass = applHost.getValueDB(node.id).getValue(devClassValueId);
+        const deviceClass = ctx.getValueDB(nodeId).getValue(devClassValueId);
         if (deviceClass) {
             deviceClasses.set(endpoint, {
                 generic: deviceClass.generic,
@@ -118,11 +120,11 @@ let MultiChannelCCAPI = class MultiChannelCCAPI extends API_1.CCAPI {
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
     async getEndpoints() {
         this.assertSupportsCommand(_Types_1.MultiChannelCommand, _Types_1.MultiChannelCommand.EndPointGet);
-        const cc = new MultiChannelCCEndPointGet(this.applHost, {
+        const cc = new MultiChannelCCEndPointGet({
             nodeId: this.endpoint.nodeId,
-            endpoint: this.endpoint.index,
+            endpointIndex: this.endpoint.index,
         });
-        const response = await this.applHost.sendCommand(cc, this.commandOptions);
+        const response = await this.host.sendCommand(cc, this.commandOptions);
         if (response) {
             return {
                 isDynamicEndpointCount: response.countIsDynamic,
@@ -135,12 +137,12 @@ let MultiChannelCCAPI = class MultiChannelCCAPI extends API_1.CCAPI {
     async getEndpointCapabilities(endpoint) {
         __assertType("endpoint", "number", __assertType__number.bind(void 0, endpoint));
         this.assertSupportsCommand(_Types_1.MultiChannelCommand, _Types_1.MultiChannelCommand.CapabilityGet);
-        const cc = new MultiChannelCCCapabilityGet(this.applHost, {
+        const cc = new MultiChannelCCCapabilityGet({
             nodeId: this.endpoint.nodeId,
-            endpoint: this.endpoint.index,
+            endpointIndex: this.endpoint.index,
             requestedEndpoint: endpoint,
         });
-        const response = await this.applHost.sendCommand(cc, this.commandOptions);
+        const response = await this.host.sendCommand(cc, this.commandOptions);
         if (response) {
             const generic = (0, safe_1.getGenericDeviceClass)(response.genericDeviceClass);
             const specific = (0, safe_1.getSpecificDeviceClass)(response.genericDeviceClass, response.specificDeviceClass);
@@ -157,24 +159,24 @@ let MultiChannelCCAPI = class MultiChannelCCAPI extends API_1.CCAPI {
         __assertType("genericClass", "number", __assertType__number.bind(void 0, genericClass));
         __assertType("specificClass", "number", __assertType__number.bind(void 0, specificClass));
         this.assertSupportsCommand(_Types_1.MultiChannelCommand, _Types_1.MultiChannelCommand.EndPointFind);
-        const cc = new MultiChannelCCEndPointFind(this.applHost, {
+        const cc = new MultiChannelCCEndPointFind({
             nodeId: this.endpoint.nodeId,
-            endpoint: this.endpoint.index,
+            endpointIndex: this.endpoint.index,
             genericClass,
             specificClass,
         });
-        const response = await this.applHost.sendCommand(cc, this.commandOptions);
+        const response = await this.host.sendCommand(cc, this.commandOptions);
         return response?.foundEndpoints;
     }
     async getAggregatedMembers(endpoint) {
         __assertType("endpoint", "number", __assertType__number.bind(void 0, endpoint));
         this.assertSupportsCommand(_Types_1.MultiChannelCommand, _Types_1.MultiChannelCommand.AggregatedMembersGet);
-        const cc = new MultiChannelCCAggregatedMembersGet(this.applHost, {
+        const cc = new MultiChannelCCAggregatedMembersGet({
             nodeId: this.endpoint.nodeId,
-            endpoint: this.endpoint.index,
+            endpointIndex: this.endpoint.index,
             requestedEndpoint: endpoint,
         });
-        const response = await this.applHost.sendCommand(cc, this.commandOptions);
+        const response = await this.host.sendCommand(cc, this.commandOptions);
         return response?.members;
     }
     // Encapsulation is used internally and too frequently that we
@@ -182,20 +184,20 @@ let MultiChannelCCAPI = class MultiChannelCCAPI extends API_1.CCAPI {
     // eslint-disable-next-line @zwave-js/ccapi-validate-args
     async sendEncapsulated(options) {
         this.assertSupportsCommand(_Types_1.MultiChannelCommand, _Types_1.MultiChannelCommand.CommandEncapsulation);
-        const cc = new MultiChannelCCCommandEncapsulation(this.applHost, {
+        const cc = new MultiChannelCCCommandEncapsulation({
             nodeId: this.endpoint.nodeId,
             ...options,
         });
-        await this.applHost.sendCommand(cc, this.commandOptions);
+        await this.host.sendCommand(cc, this.commandOptions);
     }
     async getEndpointCountV1(ccId) {
         __assertType("ccId", "CommandClasses", __assertType__number.bind(void 0, ccId));
         this.assertSupportsCommand(_Types_1.MultiChannelCommand, _Types_1.MultiChannelCommand.GetV1);
-        const cc = new MultiChannelCCV1Get(this.applHost, {
+        const cc = new MultiChannelCCV1Get({
             nodeId: this.endpoint.nodeId,
             requestedCC: ccId,
         });
-        const response = await this.applHost.sendCommand(cc, this.commandOptions);
+        const response = await this.host.sendCommand(cc, this.commandOptions);
         return response?.endpointCount;
     }
     // Encapsulation is used internally and too frequently that we
@@ -203,11 +205,11 @@ let MultiChannelCCAPI = class MultiChannelCCAPI extends API_1.CCAPI {
     // eslint-disable-next-line @zwave-js/ccapi-validate-args
     async sendEncapsulatedV1(encapsulated) {
         this.assertSupportsCommand(_Types_1.MultiChannelCommand, _Types_1.MultiChannelCommand.CommandEncapsulationV1);
-        const cc = new MultiChannelCCV1CommandEncapsulation(this.applHost, {
+        const cc = new MultiChannelCCV1CommandEncapsulation({
             nodeId: this.endpoint.nodeId,
             encapsulated,
         });
-        await this.applHost.sendCommand(cc, this.commandOptions);
+        await this.host.sendCommand(cc, this.commandOptions);
     }
 };
 exports.MultiChannelCCAPI = MultiChannelCCAPI;
@@ -221,23 +223,23 @@ let MultiChannelCC = class MultiChannelCC extends CommandClass_1.CommandClass {
             && !(cc instanceof MultiChannelCCCommandEncapsulation)
             && !(cc instanceof MultiChannelCCV1CommandEncapsulation));
     }
-    /** Encapsulates a command that targets a specific endpoint */
-    static encapsulate(host, cc) {
-        const ccVersion = host.getSafeCCVersion(safe_1.CommandClasses["Multi Channel"], cc.nodeId);
-        let ret;
-        if (ccVersion === 1) {
-            ret = new MultiChannelCCV1CommandEncapsulation(host, {
-                nodeId: cc.nodeId,
-                encapsulated: cc,
-            });
-        }
-        else {
-            ret = new MultiChannelCCCommandEncapsulation(host, {
-                nodeId: cc.nodeId,
-                encapsulated: cc,
-                destination: cc.endpointIndex,
-            });
-        }
+    /** Encapsulates a command that targets a specific endpoint, with version 2+ of the Multi Channel CC */
+    static encapsulate(cc) {
+        const ret = new MultiChannelCCCommandEncapsulation({
+            nodeId: cc.nodeId,
+            encapsulated: cc,
+            destination: cc.endpointIndex,
+        });
+        // Copy the encapsulation flags from the encapsulated command
+        ret.encapsulationFlags = cc.encapsulationFlags;
+        return ret;
+    }
+    /** Encapsulates a command that targets a specific endpoint, with version 1 of the Multi Channel CC */
+    static encapsulateV1(cc) {
+        const ret = new MultiChannelCCV1CommandEncapsulation({
+            nodeId: cc.nodeId,
+            encapsulated: cc,
+        });
         // Copy the encapsulation flags from the encapsulated command
         ret.encapsulationFlags = cc.encapsulationFlags;
         return ret;
@@ -246,40 +248,41 @@ let MultiChannelCC = class MultiChannelCC extends CommandClass_1.CommandClass {
         // The endpoints are discovered by querying the root device
         return true;
     }
-    async interview(applHost) {
-        const node = this.getNode(applHost);
-        const removeEndpoints = applHost.getDeviceConfig?.(node.id)?.compat
+    async interview(ctx) {
+        const node = this.getNode(ctx);
+        const removeEndpoints = ctx.getDeviceConfig?.(node.id)?.compat
             ?.removeEndpoints;
         if (removeEndpoints === "*") {
-            applHost.controllerLog.logNode(node.id, {
+            ctx.logNode(node.id, {
                 endpoint: this.endpointIndex,
                 message: `Skipping ${this.ccName} interview b/c all endpoints are ignored by the device config file...`,
                 direction: "none",
             });
             return;
         }
-        applHost.controllerLog.logNode(node.id, {
+        ctx.logNode(node.id, {
             endpoint: this.endpointIndex,
             message: `Interviewing ${this.ccName}...`,
             direction: "none",
         });
         // Special interview procedure for legacy nodes
-        if (this.version === 1)
-            return this.interviewV1(applHost);
+        const ccVersion = (0, CommandClass_1.getEffectiveCCVersion)(ctx, this);
+        if (ccVersion === 1)
+            return this.interviewV1(ctx);
         const endpoint = node.getEndpoint(this.endpointIndex);
-        const api = API_1.CCAPI.create(safe_1.CommandClasses["Multi Channel"], applHost, endpoint).withOptions({
+        const api = API_1.CCAPI.create(safe_1.CommandClasses["Multi Channel"], ctx, endpoint).withOptions({
             priority: safe_1.MessagePriority.NodeQuery,
         });
-        const valueDB = this.getValueDB(applHost);
+        const valueDB = this.getValueDB(ctx);
         // Step 1: Retrieve general information about end points
-        applHost.controllerLog.logNode(node.id, {
+        ctx.logNode(node.id, {
             endpoint: this.endpointIndex,
             message: "querying device endpoint information...",
             direction: "outbound",
         });
         const multiResponse = await api.getEndpoints();
         if (!multiResponse) {
-            applHost.controllerLog.logNode(node.id, {
+            ctx.logNode(node.id, {
                 endpoint: this.endpointIndex,
                 message: "Querying device endpoint information timed out, aborting interview...",
                 level: "warn",
@@ -294,7 +297,7 @@ identical capabilities:      ${multiResponse.identicalCapabilities}`;
             logMessage +=
                 `\nendpoint count (aggregated): ${multiResponse.aggregatedEndpointCount}`;
         }
-        applHost.controllerLog.logNode(node.id, {
+        ctx.logNode(node.id, {
             endpoint: this.endpointIndex,
             message: logMessage,
             direction: "inbound",
@@ -309,7 +312,7 @@ identical capabilities:      ${multiResponse.identicalCapabilities}`;
         };
         if (api.supportsCommand(_Types_1.MultiChannelCommand.EndPointFind)) {
             // Step 2a: Find all endpoints
-            applHost.controllerLog.logNode(node.id, {
+            ctx.logNode(node.id, {
                 endpoint: this.endpointIndex,
                 message: "querying all endpoints...",
                 direction: "outbound",
@@ -319,7 +322,7 @@ identical capabilities:      ${multiResponse.identicalCapabilities}`;
                 allEndpoints.push(...foundEndpoints);
             if (!allEndpoints.length) {
                 // Create a sequential list of endpoints
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     endpoint: this.endpointIndex,
                     message: `Endpoint query returned no results, assuming that endpoints are sequential`,
                     direction: "inbound",
@@ -327,7 +330,7 @@ identical capabilities:      ${multiResponse.identicalCapabilities}`;
                 addSequentialEndpoints();
             }
             else {
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     endpoint: this.endpointIndex,
                     message: `received endpoints: ${allEndpoints
                         .map(String)
@@ -338,7 +341,7 @@ identical capabilities:      ${multiResponse.identicalCapabilities}`;
         }
         else {
             // Step 2b: Assume that the endpoints are in sequential order
-            applHost.controllerLog.logNode(node.id, {
+            ctx.logNode(node.id, {
                 endpoint: this.endpointIndex,
                 message: `does not support EndPointFind, assuming that endpoints are sequential`,
                 direction: "none",
@@ -347,7 +350,7 @@ identical capabilities:      ${multiResponse.identicalCapabilities}`;
         }
         // Step 2.5: remove ignored endpoints
         if (removeEndpoints?.length) {
-            applHost.controllerLog.logNode(node.id, {
+            ctx.logNode(node.id, {
                 endpoint: this.endpointIndex,
                 message: `The following endpoints are ignored through the config file: ${removeEndpoints.join(", ")}`,
                 direction: "none",
@@ -358,16 +361,16 @@ identical capabilities:      ${multiResponse.identicalCapabilities}`;
         let hasQueriedCapabilities = false;
         for (const endpoint of allEndpoints) {
             if (endpoint > multiResponse.individualEndpointCount
-                && this.version >= 4) {
+                && ccVersion >= 4) {
                 // Find members of aggregated end point
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     endpoint: this.endpointIndex,
                     message: `querying members of aggregated endpoint #${endpoint}...`,
                     direction: "outbound",
                 });
                 const members = await api.getAggregatedMembers(endpoint);
                 if (members) {
-                    applHost.controllerLog.logNode(node.id, {
+                    ctx.logNode(node.id, {
                         endpoint: this.endpointIndex,
                         message: `aggregated endpoint #${endpoint} has members ${members
                             .map(String)
@@ -379,7 +382,7 @@ identical capabilities:      ${multiResponse.identicalCapabilities}`;
             // When the device reports identical capabilities for all endpoints,
             // we don't need to query them all
             if (multiResponse.identicalCapabilities && hasQueriedCapabilities) {
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     endpoint: this.endpointIndex,
                     message: `all endpoints identical, skipping capability query for endpoint #${endpoint}...`,
                     direction: "none",
@@ -391,7 +394,7 @@ identical capabilities:      ${multiResponse.identicalCapabilities}`;
                 valueDB.setValue(exports.MultiChannelCCValues.endpointCCs.endpoint(endpoint), [...ep1Caps]);
                 continue;
             }
-            applHost.controllerLog.logNode(node.id, {
+            ctx.logNode(node.id, {
                 endpoint: this.endpointIndex,
                 message: `querying capabilities for endpoint #${endpoint}...`,
                 direction: "outbound",
@@ -408,14 +411,14 @@ supported CCs:`;
                 for (const cc of caps.supportedCCs) {
                     logMessage += `\n  · ${(0, safe_1.getCCName)(cc)}`;
                 }
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     endpoint: this.endpointIndex,
                     message: logMessage,
                     direction: "inbound",
                 });
             }
             else {
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     endpoint: this.endpointIndex,
                     message: `Querying endpoint #${endpoint} capabilities timed out, aborting interview...`,
                     level: "warn",
@@ -426,37 +429,37 @@ supported CCs:`;
         // Now that all endpoints have been interviewed, remember which ones are there
         // But first figure out if they seem unnecessary and if they do, which ones should be preserved
         if (!multiResponse.identicalCapabilities
-            && areEndpointsUnnecessary(applHost, node, allEndpoints)) {
-            const preserve = applHost.getDeviceConfig?.(node.id)?.compat
+            && areEndpointsUnnecessary(ctx, node.id, allEndpoints)) {
+            const preserve = ctx.getDeviceConfig?.(node.id)?.compat
                 ?.preserveEndpoints;
             if (!preserve) {
                 allEndpoints = [];
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     message: `Endpoints seem unnecessary b/c they have different device classes, ignoring all...`,
                 });
             }
             else if (preserve === "*") {
                 // preserve all endpoints, do nothing
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     message: `Endpoints seem unnecessary, but are configured to be preserved.`,
                 });
             }
             else {
                 allEndpoints = allEndpoints.filter((ep) => preserve.includes(ep));
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     message: `Endpoints seem unnecessary, but endpoints ${allEndpoints.join(", ")} are configured to be preserved.`,
                 });
             }
         }
-        this.setValue(applHost, exports.MultiChannelCCValues.endpointIndizes, allEndpoints);
+        this.setValue(ctx, exports.MultiChannelCCValues.endpointIndizes, allEndpoints);
         // Remember that the interview is complete
-        this.setInterviewComplete(applHost, true);
+        this.setInterviewComplete(ctx, true);
     }
-    async interviewV1(applHost) {
-        const node = this.getNode(applHost);
-        const endpoint = this.getEndpoint(applHost);
-        const api = API_1.CCAPI.create(safe_1.CommandClasses["Multi Channel"], applHost, endpoint);
-        const valueDB = this.getValueDB(applHost);
+    async interviewV1(ctx) {
+        const node = this.getNode(ctx);
+        const endpoint = this.getEndpoint(ctx);
+        const api = API_1.CCAPI.create(safe_1.CommandClasses["Multi Channel"], ctx, endpoint);
+        const valueDB = this.getValueDB(ctx);
         // V1 works the opposite way - we scan all CCs and remember how many
         // endpoints they have
         const supportedCCs = [...node.getCCs()]
@@ -464,17 +467,17 @@ supported CCs:`;
             .filter(([, info]) => info.isSupported)
             .map(([cc]) => cc)
             // Don't query CCs that want to skip the endpoint interview
-            .filter((cc) => !CommandClass_1.CommandClass.createInstanceUnchecked(applHost, node, cc)?.skipEndpointInterview());
+            .filter((cc) => !CommandClass_1.CommandClass.createInstanceUnchecked(node, cc)?.skipEndpointInterview());
         const endpointCounts = new Map();
         for (const ccId of supportedCCs) {
-            applHost.controllerLog.logNode(node.id, {
+            ctx.logNode(node.id, {
                 message: `Querying endpoint count for CommandClass ${(0, safe_1.getCCName)(ccId)}...`,
                 direction: "outbound",
             });
             const endpointCount = await api.getEndpointCountV1(ccId);
             if (endpointCount != undefined) {
                 endpointCounts.set(ccId, endpointCount);
-                applHost.controllerLog.logNode(node.id, {
+                ctx.logNode(node.id, {
                     message: `CommandClass ${(0, safe_1.getCCName)(ccId)} has ${endpointCount} endpoints`,
                     direction: "inbound",
                 });
@@ -483,12 +486,12 @@ supported CCs:`;
         // Store the collected information
         // We have only individual and no dynamic and no aggregated endpoints
         const numEndpoints = Math.max(...endpointCounts.values());
-        this.setValue(applHost, exports.MultiChannelCCValues.endpointCountIsDynamic, false);
-        this.setValue(applHost, exports.MultiChannelCCValues.aggregatedEndpointCount, 0);
-        this.setValue(applHost, exports.MultiChannelCCValues.individualEndpointCount, numEndpoints);
+        this.setValue(ctx, exports.MultiChannelCCValues.endpointCountIsDynamic, false);
+        this.setValue(ctx, exports.MultiChannelCCValues.aggregatedEndpointCount, 0);
+        this.setValue(ctx, exports.MultiChannelCCValues.individualEndpointCount, numEndpoints);
         // Since we queried all CCs separately, we can assume that all
         // endpoints have different capabilities
-        this.setValue(applHost, exports.MultiChannelCCValues.endpointsHaveIdenticalCapabilities, false);
+        this.setValue(ctx, exports.MultiChannelCCValues.endpointsHaveIdenticalCapabilities, false);
         for (let endpoint = 1; endpoint <= numEndpoints; endpoint++) {
             // Check which CCs exist on this endpoint
             const endpointCCs = [...endpointCounts.entries()]
@@ -498,7 +501,7 @@ supported CCs:`;
             valueDB.setValue(exports.MultiChannelCCValues.endpointCCs.endpoint(endpoint), endpointCCs);
         }
         // Remember that the interview is complete
-        this.setInterviewComplete(applHost, true);
+        this.setInterviewComplete(ctx, true);
     }
 };
 exports.MultiChannelCC = MultiChannelCC;
@@ -507,39 +510,45 @@ exports.MultiChannelCC = MultiChannelCC = __decorate([
     (0, CommandClassDecorators_1.implementedVersion)(4),
     (0, CommandClassDecorators_1.ccValues)(exports.MultiChannelCCValues)
 ], MultiChannelCC);
-let MultiChannelCCEndPointReport = class MultiChannelCCEndPointReport extends MultiChannelCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 2);
-            this.countIsDynamic = !!(this.payload[0] & 0b10000000);
-            this.identicalCapabilities = !!(this.payload[0] & 0b01000000);
-            this.individualCount = this.payload[1] & 0b01111111;
-            if (this.version >= 4 && this.payload.length >= 3) {
-                this.aggregatedCount = this.payload[2] & 0b01111111;
-            }
-        }
-        else {
-            this.countIsDynamic = options.countIsDynamic;
-            this.identicalCapabilities = options.identicalCapabilities;
-            this.individualCount = options.individualCount;
-            this.aggregatedCount = options.aggregatedCount;
+let MultiChannelCCEndPointReport = MultiChannelCCEndPointReport_1 = class MultiChannelCCEndPointReport extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.countIsDynamic = options.countIsDynamic;
+        this.identicalCapabilities = options.identicalCapabilities;
+        this.individualCount = options.individualCount;
+        this.aggregatedCount = options.aggregatedCount;
+    }
+    static from(raw, ctx) {
+        (0, safe_1.validatePayload)(raw.payload.length >= 2);
+        const countIsDynamic = !!(raw.payload[0] & 0b10000000);
+        const identicalCapabilities = !!(raw.payload[0] & 0b01000000);
+        const individualCount = raw.payload[1] & 0b01111111;
+        let aggregatedCount;
+        if (raw.payload.length >= 3) {
+            aggregatedCount = raw.payload[2] & 0b01111111;
         }
+        return new MultiChannelCCEndPointReport_1({
+            nodeId: ctx.sourceNodeId,
+            countIsDynamic,
+            identicalCapabilities,
+            individualCount,
+            aggregatedCount,
+        });
     }
     countIsDynamic;
     identicalCapabilities;
     individualCount;
     aggregatedCount;
-    serialize() {
+    serialize(ctx) {
         this.payload = Buffer.from([
             (this.countIsDynamic ? 0b10000000 : 0)
                 | (this.identicalCapabilities ? 0b01000000 : 0),
             this.individualCount & 0b01111111,
             this.aggregatedCount ?? 0,
         ]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         const message = {
             "endpoint count (individual)": this.individualCount,
             "count is dynamic": this.countIsDynamic,
@@ -549,7 +558,7 @@ let MultiChannelCCEndPointReport = class MultiChannelCCEndPointReport extends Mu
             message["endpoint count (aggregated)"] = this.aggregatedCount;
         }
         const ret = {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message,
         };
         return ret;
@@ -568,7 +577,7 @@ __decorate([
 __decorate([
     (0, CommandClassDecorators_1.ccValue)(exports.MultiChannelCCValues.aggregatedEndpointCount)
 ], MultiChannelCCEndPointReport.prototype, "aggregatedCount", void 0);
-exports.MultiChannelCCEndPointReport = MultiChannelCCEndPointReport = __decorate([
+exports.MultiChannelCCEndPointReport = MultiChannelCCEndPointReport = MultiChannelCCEndPointReport_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultiChannelCommand.EndPointReport)
 ], MultiChannelCCEndPointReport);
 let MultiChannelCCEndPointGet = class MultiChannelCCEndPointGet extends MultiChannelCC {
@@ -578,48 +587,55 @@ exports.MultiChannelCCEndPointGet = MultiChannelCCEndPointGet = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultiChannelCommand.EndPointGet),
     (0, CommandClassDecorators_1.expectedCCResponse)(MultiChannelCCEndPointReport)
 ], MultiChannelCCEndPointGet);
-let MultiChannelCCCapabilityReport = class MultiChannelCCCapabilityReport extends MultiChannelCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            // Only validate the bytes we expect to see here
-            // parseApplicationNodeInformation does its own validation
-            (0, safe_1.validatePayload)(this.payload.length >= 1);
-            this.endpointIndex = this.payload[0] & 0b01111111;
-            this.isDynamic = !!(this.payload[0] & 0b10000000);
-            const NIF = (0, safe_1.parseApplicationNodeInformation)(this.payload.subarray(1));
-            this.genericDeviceClass = NIF.genericDeviceClass;
-            this.specificDeviceClass = NIF.specificDeviceClass;
-            this.supportedCCs = NIF.supportedCCs;
-            // Removal reports have very specific information
-            this.wasRemoved = this.isDynamic
-                && this.genericDeviceClass === 0xff // "Non-Interoperable"
-                && this.specificDeviceClass === 0x00;
-        }
-        else {
-            this.endpointIndex = options.endpointIndex;
-            this.genericDeviceClass = options.genericDeviceClass;
-            this.specificDeviceClass = options.specificDeviceClass;
-            this.supportedCCs = options.supportedCCs;
-            this.isDynamic = options.isDynamic;
-            this.wasRemoved = options.wasRemoved;
-        }
+let MultiChannelCCCapabilityReport = MultiChannelCCCapabilityReport_1 = class MultiChannelCCCapabilityReport extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.endpointIndex = options.endpointIndex;
+        this.genericDeviceClass = options.genericDeviceClass;
+        this.specificDeviceClass = options.specificDeviceClass;
+        this.supportedCCs = options.supportedCCs;
+        this.isDynamic = options.isDynamic;
+        this.wasRemoved = options.wasRemoved;
+    }
+    static from(raw, ctx) {
+        // Only validate the bytes we expect to see here
+        // parseApplicationNodeInformation does its own validation
+        (0, safe_1.validatePayload)(raw.payload.length >= 1);
+        const endpointIndex = raw.payload[0] & 0b01111111;
+        const isDynamic = !!(raw.payload[0] & 0b10000000);
+        const NIF = (0, safe_1.parseApplicationNodeInformation)(raw.payload.subarray(1));
+        const genericDeviceClass = NIF.genericDeviceClass;
+        const specificDeviceClass = NIF.specificDeviceClass;
+        const supportedCCs = NIF.supportedCCs;
+        // Removal reports have very specific information
+        const wasRemoved = isDynamic
+            && genericDeviceClass === 0xff // "Non-Interoperable"
+            && specificDeviceClass === 0x00;
+        return new MultiChannelCCCapabilityReport_1({
+            nodeId: ctx.sourceNodeId,
+            endpointIndex,
+            isDynamic,
+            genericDeviceClass,
+            specificDeviceClass,
+            supportedCCs,
+            wasRemoved,
+        });
     }
-    persistValues(applHost) {
-        if (!super.persistValues(applHost))
+    persistValues(ctx) {
+        if (!super.persistValues(ctx))
             return false;
         const deviceClassValue = exports.MultiChannelCCValues.endpointDeviceClass;
         const ccsValue = exports.MultiChannelCCValues.endpointCCs;
         if (this.wasRemoved) {
-            this.removeValue(applHost, deviceClassValue);
-            this.removeValue(applHost, ccsValue);
+            this.removeValue(ctx, deviceClassValue);
+            this.removeValue(ctx, ccsValue);
         }
         else {
-            this.setValue(applHost, deviceClassValue, {
+            this.setValue(ctx, deviceClassValue, {
                 generic: this.genericDeviceClass,
                 specific: this.specificDeviceClass,
             });
-            this.setValue(applHost, ccsValue, this.supportedCCs);
+            this.setValue(ctx, ccsValue, this.supportedCCs);
         }
         return true;
     }
@@ -629,7 +645,7 @@ let MultiChannelCCCapabilityReport = class MultiChannelCCCapabilityReport extend
     supportedCCs;
     isDynamic;
     wasRemoved;
-    serialize() {
+    serialize(ctx) {
         this.payload = Buffer.concat([
             Buffer.from([
                 (this.endpointIndex & 0b01111111)
@@ -637,11 +653,11 @@ let MultiChannelCCCapabilityReport = class MultiChannelCCCapabilityReport extend
             ]),
             (0, safe_1.encodeApplicationNodeInformation)(this),
         ]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 "endpoint index": this.endpointIndex,
                 "generic device class": (0, safe_1.getGenericDeviceClass)(this.genericDeviceClass).label,
@@ -655,66 +671,73 @@ let MultiChannelCCCapabilityReport = class MultiChannelCCCapabilityReport extend
     }
 };
 exports.MultiChannelCCCapabilityReport = MultiChannelCCCapabilityReport;
-exports.MultiChannelCCCapabilityReport = MultiChannelCCCapabilityReport = __decorate([
+exports.MultiChannelCCCapabilityReport = MultiChannelCCCapabilityReport = MultiChannelCCCapabilityReport_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultiChannelCommand.CapabilityReport)
 ], MultiChannelCCCapabilityReport);
 function testResponseForMultiChannelCapabilityGet(sent, received) {
     return received.endpointIndex === sent.requestedEndpoint;
 }
-let MultiChannelCCCapabilityGet = class MultiChannelCCCapabilityGet extends MultiChannelCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 1);
-            this.requestedEndpoint = this.payload[0] & 0b01111111;
-        }
-        else {
-            this.requestedEndpoint = options.requestedEndpoint;
-        }
+let MultiChannelCCCapabilityGet = MultiChannelCCCapabilityGet_1 = class MultiChannelCCCapabilityGet extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.requestedEndpoint = options.requestedEndpoint;
+    }
+    static from(raw, ctx) {
+        (0, safe_1.validatePayload)(raw.payload.length >= 1);
+        const requestedEndpoint = raw.payload[0] & 0b01111111;
+        return new MultiChannelCCCapabilityGet_1({
+            nodeId: ctx.sourceNodeId,
+            requestedEndpoint,
+        });
     }
     requestedEndpoint;
-    serialize() {
+    serialize(ctx) {
         this.payload = Buffer.from([this.requestedEndpoint & 0b01111111]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: { endpoint: this.requestedEndpoint },
         };
     }
 };
 exports.MultiChannelCCCapabilityGet = MultiChannelCCCapabilityGet;
-exports.MultiChannelCCCapabilityGet = MultiChannelCCCapabilityGet = __decorate([
+exports.MultiChannelCCCapabilityGet = MultiChannelCCCapabilityGet = MultiChannelCCCapabilityGet_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultiChannelCommand.CapabilityGet),
     (0, CommandClassDecorators_1.expectedCCResponse)(MultiChannelCCCapabilityReport, testResponseForMultiChannelCapabilityGet)
 ], MultiChannelCCCapabilityGet);
-let MultiChannelCCEndPointFindReport = class MultiChannelCCEndPointFindReport extends MultiChannelCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 3);
-            this.reportsToFollow = this.payload[0];
-            this.genericClass = this.payload[1];
-            this.specificClass = this.payload[2];
-            // Some devices omit the endpoint list although that is not allowed in the specs
-            // therefore don't validatePayload here.
-            this.foundEndpoints = [...this.payload.subarray(3)]
-                .map((e) => e & 0b01111111)
-                .filter((e) => e !== 0);
-        }
-        else {
-            this.genericClass = options.genericClass;
-            this.specificClass = options.specificClass;
-            this.foundEndpoints = options.foundEndpoints;
-            this.reportsToFollow = options.reportsToFollow;
-        }
+let MultiChannelCCEndPointFindReport = MultiChannelCCEndPointFindReport_1 = class MultiChannelCCEndPointFindReport extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.genericClass = options.genericClass;
+        this.specificClass = options.specificClass;
+        this.foundEndpoints = options.foundEndpoints;
+        this.reportsToFollow = options.reportsToFollow;
+    }
+    static from(raw, ctx) {
+        (0, safe_1.validatePayload)(raw.payload.length >= 3);
+        const reportsToFollow = raw.payload[0];
+        const genericClass = raw.payload[1];
+        const specificClass = raw.payload[2];
+        // Some devices omit the endpoint list although that is not allowed in the specs
+        // therefore don't validatePayload here.
+        const foundEndpoints = [...raw.payload.subarray(3)]
+            .map((e) => e & 0b01111111)
+            .filter((e) => e !== 0);
+        return new MultiChannelCCEndPointFindReport_1({
+            nodeId: ctx.sourceNodeId,
+            reportsToFollow,
+            genericClass,
+            specificClass,
+            foundEndpoints,
+        });
     }
     genericClass;
     specificClass;
     foundEndpoints;
     reportsToFollow;
-    serialize() {
+    serialize(ctx) {
         this.payload = Buffer.concat([
             Buffer.from([
                 this.reportsToFollow,
@@ -723,7 +746,7 @@ let MultiChannelCCEndPointFindReport = class MultiChannelCCEndPointFindReport ex
             ]),
             Buffer.from(this.foundEndpoints.map((e) => e & 0b01111111)),
         ]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
     getPartialCCSessionId() {
         // Distinguish sessions by the requested device classes
@@ -735,15 +758,15 @@ let MultiChannelCCEndPointFindReport = class MultiChannelCCEndPointFindReport ex
     expectMoreMessages() {
         return this.reportsToFollow > 0;
     }
-    mergePartialCCs(applHost, partials) {
+    mergePartialCCs(partials, _ctx) {
         // Concat the list of end points
         this.foundEndpoints = [...partials, this]
             .map((report) => report.foundEndpoints)
             .reduce((prev, cur) => prev.concat(...cur), []);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 "generic device class": (0, safe_1.getGenericDeviceClass)(this.genericClass).label,
                 "specific device class": (0, safe_1.getSpecificDeviceClass)(this.genericClass, this.specificClass).label,
@@ -754,31 +777,34 @@ let MultiChannelCCEndPointFindReport = class MultiChannelCCEndPointFindReport ex
     }
 };
 exports.MultiChannelCCEndPointFindReport = MultiChannelCCEndPointFindReport;
-exports.MultiChannelCCEndPointFindReport = MultiChannelCCEndPointFindReport = __decorate([
+exports.MultiChannelCCEndPointFindReport = MultiChannelCCEndPointFindReport = MultiChannelCCEndPointFindReport_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultiChannelCommand.EndPointFindReport)
 ], MultiChannelCCEndPointFindReport);
-let MultiChannelCCEndPointFind = class MultiChannelCCEndPointFind extends MultiChannelCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 2);
-            this.genericClass = this.payload[0];
-            this.specificClass = this.payload[1];
-        }
-        else {
-            this.genericClass = options.genericClass;
-            this.specificClass = options.specificClass;
-        }
+let MultiChannelCCEndPointFind = MultiChannelCCEndPointFind_1 = class MultiChannelCCEndPointFind extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.genericClass = options.genericClass;
+        this.specificClass = options.specificClass;
+    }
+    static from(raw, ctx) {
+        (0, safe_1.validatePayload)(raw.payload.length >= 2);
+        const genericClass = raw.payload[0];
+        const specificClass = raw.payload[1];
+        return new MultiChannelCCEndPointFind_1({
+            nodeId: ctx.sourceNodeId,
+            genericClass,
+            specificClass,
+        });
     }
     genericClass;
     specificClass;
-    serialize() {
+    serialize(ctx) {
         this.payload = Buffer.from([this.genericClass, this.specificClass]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 "generic device class": (0, safe_1.getGenericDeviceClass)(this.genericClass).label,
                 "specific device class": (0, safe_1.getSpecificDeviceClass)(this.genericClass, this.specificClass).label,
@@ -787,25 +813,35 @@ let MultiChannelCCEndPointFind = class MultiChannelCCEndPointFind extends MultiC
     }
 };
 exports.MultiChannelCCEndPointFind = MultiChannelCCEndPointFind;
-exports.MultiChannelCCEndPointFind = MultiChannelCCEndPointFind = __decorate([
+exports.MultiChannelCCEndPointFind = MultiChannelCCEndPointFind = MultiChannelCCEndPointFind_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultiChannelCommand.EndPointFind),
     (0, CommandClassDecorators_1.expectedCCResponse)(MultiChannelCCEndPointFindReport)
 ], MultiChannelCCEndPointFind);
-let MultiChannelCCAggregatedMembersReport = class MultiChannelCCAggregatedMembersReport extends MultiChannelCC {
-    constructor(host, options) {
-        super(host, options);
-        (0, safe_1.validatePayload)(this.payload.length >= 2);
-        this.aggregatedEndpointIndex = this.payload[0] & 0b0111_1111;
-        const bitMaskLength = this.payload[1];
-        (0, safe_1.validatePayload)(this.payload.length >= 2 + bitMaskLength);
-        const bitMask = this.payload.subarray(2, 2 + bitMaskLength);
-        this.members = (0, safe_1.parseBitMask)(bitMask);
+let MultiChannelCCAggregatedMembersReport = MultiChannelCCAggregatedMembersReport_1 = class MultiChannelCCAggregatedMembersReport extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.aggregatedEndpointIndex = options.aggregatedEndpointIndex;
+        this.members = options.members;
+    }
+    static from(raw, ctx) {
+        (0, safe_1.validatePayload)(raw.payload.length >= 2);
+        const aggregatedEndpointIndex = raw.payload[0] & 0b0111_1111;
+        const bitMaskLength = raw.payload[1];
+        (0, safe_1.validatePayload)(raw.payload.length >= 2 + bitMaskLength);
+        const bitMask = raw.payload.subarray(2, 2 + bitMaskLength);
+        const members = (0, safe_1.parseBitMask)(bitMask);
+        return new MultiChannelCCAggregatedMembersReport_1({
+            nodeId: ctx.sourceNodeId,
+            aggregatedEndpointIndex,
+            members,
+        });
     }
     aggregatedEndpointIndex;
     members;
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 "aggregated endpoint": this.aggregatedEndpointIndex,
                 members: this.members.join(", "),
@@ -817,28 +853,29 @@ exports.MultiChannelCCAggregatedMembersReport = MultiChannelCCAggregatedMembersR
 __decorate([
     (0, CommandClassDecorators_1.ccValue)(exports.MultiChannelCCValues.aggregatedEndpointMembers, (self) => [self.aggregatedEndpointIndex])
 ], MultiChannelCCAggregatedMembersReport.prototype, "members", void 0);
-exports.MultiChannelCCAggregatedMembersReport = MultiChannelCCAggregatedMembersReport = __decorate([
+exports.MultiChannelCCAggregatedMembersReport = MultiChannelCCAggregatedMembersReport = MultiChannelCCAggregatedMembersReport_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultiChannelCommand.AggregatedMembersReport)
 ], MultiChannelCCAggregatedMembersReport);
 let MultiChannelCCAggregatedMembersGet = class MultiChannelCCAggregatedMembersGet extends MultiChannelCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            // TODO: Deserialize payload
-            throw new safe_1.ZWaveError(`${this.constructor.name}: deserialization not implemented`, safe_1.ZWaveErrorCodes.Deserialization_NotImplemented);
-        }
-        else {
-            this.requestedEndpoint = options.requestedEndpoint;
-        }
+    constructor(options) {
+        super(options);
+        this.requestedEndpoint = options.requestedEndpoint;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new safe_1.ZWaveError(`${this.name}: deserialization not implemented`, safe_1.ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new MultiChannelCCAggregatedMembersGet({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
     }
     requestedEndpoint;
-    serialize() {
+    serialize(ctx) {
         this.payload = Buffer.from([this.requestedEndpoint & 0b0111_1111]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: { endpoint: this.requestedEndpoint },
         };
     }
@@ -871,55 +908,69 @@ function testResponseForCommandEncapsulation(sent, received) {
     }
     return false;
 }
-let MultiChannelCCCommandEncapsulation = class MultiChannelCCCommandEncapsulation extends MultiChannelCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 2);
-            if (this.host.getDeviceConfig?.(this.nodeId)?.compat
-                ?.treatDestinationEndpointAsSource) {
-                // This device incorrectly uses the destination field to indicate the source endpoint
-                this.endpointIndex = this.payload[1] & 0b0111_1111;
-                this.destination = 0;
+let MultiChannelCCCommandEncapsulation = MultiChannelCCCommandEncapsulation_1 = class MultiChannelCCCommandEncapsulation extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.encapsulated = options.encapsulated;
+        this.encapsulated.encapsulatingCC = this;
+        // Propagate the endpoint index all the way down
+        let cur = this;
+        while (cur) {
+            if ((0, EncapsulatingCommandClass_1.isMultiEncapsulatingCommandClass)(cur)) {
+                for (const cc of cur.encapsulated) {
+                    cc.endpointIndex = this.endpointIndex;
+                }
+                break;
+            }
+            else if ((0, EncapsulatingCommandClass_1.isEncapsulatingCommandClass)(cur)) {
+                cur.encapsulated.endpointIndex = this.endpointIndex;
+                cur = cur.encapsulated;
             }
             else {
-                // Parse normally
-                this.endpointIndex = this.payload[0] & 0b0111_1111;
-                const isBitMask = !!(this.payload[1] & 0b1000_0000);
-                const destination = this.payload[1] & 0b0111_1111;
-                if (isBitMask) {
-                    this.destination = (0, safe_1.parseBitMask)(Buffer.from([destination]));
-                }
-                else {
-                    this.destination = destination;
-                }
+                break;
             }
-            // No need to validate further, each CC does it for itself
-            this.encapsulated = CommandClass_1.CommandClass.from(this.host, {
-                data: this.payload.subarray(2),
-                fromEncapsulation: true,
-                encapCC: this,
-                origin: options.origin,
-                frameType: options.frameType,
-            });
+        }
+        this.destination = options.destination;
+    }
+    static from(raw, ctx) {
+        (0, safe_1.validatePayload)(raw.payload.length >= 2);
+        let endpointIndex;
+        let destination;
+        if (ctx.getDeviceConfig?.(ctx.sourceNodeId)
+            ?.compat?.treatDestinationEndpointAsSource) {
+            // This device incorrectly uses the destination field to indicate the source endpoint
+            endpointIndex = raw.payload[1] & 0b0111_1111;
+            destination = 0;
         }
         else {
-            this.encapsulated = options.encapsulated;
-            options.encapsulated.encapsulatingCC = this;
-            this.destination = options.destination;
-            if (this.host.getDeviceConfig?.(this.nodeId)?.compat
-                ?.treatDestinationEndpointAsSource) {
-                // This device incorrectly responds from the endpoint we've passed as our source endpoint
-                if (typeof this.destination === "number") {
-                    this.endpointIndex = this.destination;
-                }
+            // Parse normally
+            endpointIndex = raw.payload[0] & 0b0111_1111;
+            const isBitMask = !!(raw.payload[1] & 0b1000_0000);
+            destination = raw.payload[1] & 0b0111_1111;
+            if (isBitMask) {
+                destination = (0, safe_1.parseBitMask)(Buffer.from([destination]));
             }
         }
+        // No need to validate further, each CC does it for itself
+        const encapsulated = CommandClass_1.CommandClass.parse(raw.payload.subarray(2), ctx);
+        return new MultiChannelCCCommandEncapsulation_1({
+            nodeId: ctx.sourceNodeId,
+            endpointIndex,
+            destination,
+            encapsulated,
+        });
     }
     encapsulated;
     /** The destination end point (0-127) or an array of destination end points (1-7) */
     destination;
-    serialize() {
+    serialize(ctx) {
+        if (ctx.getDeviceConfig?.(this.nodeId)?.compat
+            ?.treatDestinationEndpointAsSource) {
+            // This device incorrectly responds from the endpoint we've passed as our source endpoint
+            if (typeof this.destination === "number") {
+                this.endpointIndex = this.destination;
+            }
+        }
         const destination = typeof this.destination === "number"
             // The destination is a single number
             ? this.destination & 0b0111_1111
@@ -927,13 +978,13 @@ let MultiChannelCCCommandEncapsulation = class MultiChannelCCCommandEncapsulatio
             : (0, safe_1.encodeBitMask)(this.destination, 7)[0] | 0b1000_0000;
         this.payload = Buffer.concat([
             Buffer.from([this.endpointIndex & 0b0111_1111, destination]),
-            this.encapsulated.serialize(),
+            this.encapsulated.serialize(ctx),
         ]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 source: this.endpointIndex,
                 destination: typeof this.destination === "number"
@@ -948,23 +999,33 @@ let MultiChannelCCCommandEncapsulation = class MultiChannelCCCommandEncapsulatio
     }
 };
 exports.MultiChannelCCCommandEncapsulation = MultiChannelCCCommandEncapsulation;
-exports.MultiChannelCCCommandEncapsulation = MultiChannelCCCommandEncapsulation = __decorate([
+exports.MultiChannelCCCommandEncapsulation = MultiChannelCCCommandEncapsulation = MultiChannelCCCommandEncapsulation_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultiChannelCommand.CommandEncapsulation),
     (0, CommandClassDecorators_1.expectedCCResponse)(getCCResponseForCommandEncapsulation, testResponseForCommandEncapsulation)
 ], MultiChannelCCCommandEncapsulation);
-let MultiChannelCCV1Report = class MultiChannelCCV1Report extends MultiChannelCC {
-    constructor(host, options) {
-        super(host, options);
+let MultiChannelCCV1Report = MultiChannelCCV1Report_1 = class MultiChannelCCV1Report extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        // TODO: Check implementation:
+        this.requestedCC = options.requestedCC;
+        this.endpointCount = options.endpointCount;
+    }
+    static from(raw, ctx) {
         // V1 won't be extended in the future, so do an exact check
-        (0, safe_1.validatePayload)(this.payload.length === 2);
-        this.requestedCC = this.payload[0];
-        this.endpointCount = this.payload[1];
+        (0, safe_1.validatePayload)(raw.payload.length === 2);
+        const requestedCC = raw.payload[0];
+        const endpointCount = raw.payload[1];
+        return new MultiChannelCCV1Report_1({
+            nodeId: ctx.sourceNodeId,
+            requestedCC,
+            endpointCount,
+        });
     }
     requestedCC;
     endpointCount;
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: {
                 CC: (0, safe_1.getCCName)(this.requestedCC),
                 "# of endpoints": this.endpointCount,
@@ -973,31 +1034,32 @@ let MultiChannelCCV1Report = class MultiChannelCCV1Report extends MultiChannelCC
     }
 };
 exports.MultiChannelCCV1Report = MultiChannelCCV1Report;
-exports.MultiChannelCCV1Report = MultiChannelCCV1Report = __decorate([
+exports.MultiChannelCCV1Report = MultiChannelCCV1Report = MultiChannelCCV1Report_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultiChannelCommand.ReportV1)
 ], MultiChannelCCV1Report);
 function testResponseForMultiChannelV1Get(sent, received) {
     return sent.requestedCC === received.requestedCC;
 }
 let MultiChannelCCV1Get = class MultiChannelCCV1Get extends MultiChannelCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            // TODO: Deserialize payload
-            throw new safe_1.ZWaveError(`${this.constructor.name}: deserialization not implemented`, safe_1.ZWaveErrorCodes.Deserialization_NotImplemented);
-        }
-        else {
-            this.requestedCC = options.requestedCC;
-        }
+    constructor(options) {
+        super(options);
+        this.requestedCC = options.requestedCC;
+    }
+    static from(_raw, _ctx) {
+        // TODO: Deserialize payload
+        throw new safe_1.ZWaveError(`${this.name}: deserialization not implemented`, safe_1.ZWaveErrorCodes.Deserialization_NotImplemented);
+        // return new MultiChannelCCV1Get({
+        // 	nodeId: ctx.sourceNodeId,
+        // });
     }
     requestedCC;
-    serialize() {
+    serialize(ctx) {
         this.payload = Buffer.from([this.requestedCC]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: { CC: (0, safe_1.getCCName)(this.requestedCC) },
         };
     }
@@ -1018,52 +1080,49 @@ function testResponseForV1CommandEncapsulation(sent, received) {
     }
     return false;
 }
-let MultiChannelCCV1CommandEncapsulation = class MultiChannelCCV1CommandEncapsulation extends MultiChannelCC {
-    constructor(host, options) {
-        super(host, options);
-        if ((0, CommandClass_1.gotDeserializationOptions)(options)) {
-            (0, safe_1.validatePayload)(this.payload.length >= 1);
-            this.endpointIndex = this.payload[0];
-            // Some devices send invalid reports, i.e. MultiChannelCCV1CommandEncapsulation, but with V2+ binary format
-            // This would be a NoOp CC, but it makes no sense to encapsulate that.
-            const isV2withV1Header = this.payload.length >= 2
-                && this.payload[1] === 0x00;
-            // No need to validate further, each CC does it for itself
-            this.encapsulated = CommandClass_1.CommandClass.from(this.host, {
-                data: this.payload.subarray(isV2withV1Header ? 2 : 1),
-                fromEncapsulation: true,
-                encapCC: this,
-                origin: options.origin,
-                frameType: options.frameType,
-            });
-        }
-        else {
-            this.encapsulated = options.encapsulated;
-            // No need to distinguish between source and destination in V1
-            this.endpointIndex = this.encapsulated.endpointIndex;
-        }
+let MultiChannelCCV1CommandEncapsulation = MultiChannelCCV1CommandEncapsulation_1 = class MultiChannelCCV1CommandEncapsulation extends MultiChannelCC {
+    constructor(options) {
+        super(options);
+        this.encapsulated = options.encapsulated;
+        // No need to distinguish between source and destination in V1
+        this.endpointIndex = this.encapsulated.endpointIndex;
+    }
+    static from(raw, ctx) {
+        (0, safe_1.validatePayload)(raw.payload.length >= 1);
+        const endpointIndex = raw.payload[0];
+        // Some devices send invalid reports, i.e. MultiChannelCCV1CommandEncapsulation, but with V2+ binary format
+        // This would be a NoOp CC, but it makes no sense to encapsulate that.
+        const isV2withV1Header = raw.payload.length >= 2
+            && raw.payload[1] === 0x00;
+        // No need to validate further, each CC does it for itself
+        const encapsulated = CommandClass_1.CommandClass.parse(raw.payload.subarray(isV2withV1Header ? 2 : 1), ctx);
+        return new MultiChannelCCV1CommandEncapsulation_1({
+            nodeId: ctx.sourceNodeId,
+            endpointIndex,
+            encapsulated,
+        });
     }
     encapsulated;
-    serialize() {
+    serialize(ctx) {
         this.payload = Buffer.concat([
             Buffer.from([this.endpointIndex]),
-            this.encapsulated.serialize(),
+            this.encapsulated.serialize(ctx),
         ]);
-        return super.serialize();
+        return super.serialize(ctx);
     }
     computeEncapsulationOverhead() {
         // Multi Channel CC V1 adds one byte for the endpoint index
         return super.computeEncapsulationOverhead() + 1;
     }
-    toLogEntry(host) {
+    toLogEntry(ctx) {
         return {
-            ...super.toLogEntry(host),
+            ...super.toLogEntry(ctx),
             message: { source: this.endpointIndex },
         };
     }
 };
 exports.MultiChannelCCV1CommandEncapsulation = MultiChannelCCV1CommandEncapsulation;
-exports.MultiChannelCCV1CommandEncapsulation = MultiChannelCCV1CommandEncapsulation = __decorate([
+exports.MultiChannelCCV1CommandEncapsulation = MultiChannelCCV1CommandEncapsulation = MultiChannelCCV1CommandEncapsulation_1 = __decorate([
     (0, CommandClassDecorators_1.CCCommand)(_Types_1.MultiChannelCommand.CommandEncapsulationV1),
     (0, CommandClassDecorators_1.expectedCCResponse)(getResponseForV1CommandEncapsulation, testResponseForV1CommandEncapsulation)
 ], MultiChannelCCV1CommandEncapsulation);