@zwave-js/cc 9.3.1-0-pr-4662-79458fb

package/build/lib/utils.js

@@ -0,0 +1,675 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureLifelineAssociations = exports.removeAssociations = exports.addAssociations = exports.getAllAssociationGroups = exports.getAssociationGroups = exports.isAssociationAllowed = exports.getAllAssociations = exports.getAssociations = void 0;
+const safe_1 = require("@zwave-js/core/safe");
+const safe_2 = require("@zwave-js/shared/safe");
+const arrays_1 = require("alcalzone-shared/arrays");
+const AssociationCC_1 = require("../cc/AssociationCC");
+const AssociationGroupInfoCC_1 = require("../cc/AssociationGroupInfoCC");
+const MultiChannelAssociationCC_1 = require("../cc/MultiChannelAssociationCC");
+const API_1 = require("./API");
+function getAssociations(applHost, endpoint) {
+    const ret = new Map();
+    if (endpoint.supportsCC(safe_1.CommandClasses.Association)) {
+        const destinations = AssociationCC_1.AssociationCC.getAllDestinationsCached(applHost, endpoint);
+        for (const [groupId, assocs] of destinations) {
+            ret.set(groupId, assocs);
+        }
+    }
+    else {
+        throw new safe_1.ZWaveError(`Node ${endpoint.nodeId}${endpoint.index > 0 ? `, endpoint ${endpoint.index}` : ""} does not support associations!`, safe_1.ZWaveErrorCodes.CC_NotSupported);
+    }
+    // Merge the "normal" destinations with multi channel destinations
+    if (endpoint.supportsCC(safe_1.CommandClasses["Multi Channel Association"])) {
+        const destinations = MultiChannelAssociationCC_1.MultiChannelAssociationCC.getAllDestinationsCached(applHost, endpoint);
+        for (const [groupId, assocs] of destinations) {
+            if (ret.has(groupId)) {
+                const normalAssociations = ret.get(groupId);
+                ret.set(groupId, [
+                    ...normalAssociations,
+                    // Eliminate potential duplicates
+                    ...assocs.filter((a1) => normalAssociations.findIndex((a2) => a1.nodeId === a2.nodeId &&
+                        a1.endpoint === a2.endpoint) === -1),
+                ]);
+            }
+            else {
+                ret.set(groupId, assocs);
+            }
+        }
+    }
+    return ret;
+}
+exports.getAssociations = getAssociations;
+function getAllAssociations(applHost, node) {
+    const ret = new safe_2.ObjectKeyMap();
+    for (const endpoint of node.getAllEndpoints()) {
+        const address = {
+            nodeId: node.id,
+            endpoint: endpoint.index,
+        };
+        if (endpoint.supportsCC(safe_1.CommandClasses.Association)) {
+            ret.set(address, getAssociations(applHost, endpoint));
+        }
+    }
+    return ret;
+}
+exports.getAllAssociations = getAllAssociations;
+function isAssociationAllowed(applHost, endpoint, group, destination) {
+    var _a;
+    // Check that the target endpoint exists except when adding an association to the controller
+    const targetNode = applHost.nodes.getOrThrow(destination.nodeId);
+    const targetEndpoint = destination.nodeId === applHost.ownNodeId
+        ? targetNode
+        : targetNode.getEndpointOrThrow((_a = destination.endpoint) !== null && _a !== void 0 ? _a : 0);
+    // SDS14223:
+    // A controlling node MUST NOT associate Node A to a Node B destination that does not support
+    // the Command Class that the Node A will be controlling
+    //
+    // To determine this, the node must support the AGI CC or we have no way of knowing which
+    // CCs the node will control
+    if (!endpoint.supportsCC(safe_1.CommandClasses.Association) &&
+        !endpoint.supportsCC(safe_1.CommandClasses["Multi Channel Association"])) {
+        throw new safe_1.ZWaveError(`Node ${endpoint.nodeId}${endpoint.index > 0 ? `, endpoint ${endpoint.index}` : ""} does not support associations!`, safe_1.ZWaveErrorCodes.CC_NotSupported);
+    }
+    else if (!endpoint.supportsCC(safe_1.CommandClasses["Association Group Information"])) {
+        return true;
+    }
+    // The following checks don't apply to Lifeline associations
+    if (destination.nodeId === applHost.ownNodeId)
+        return true;
+    const groupCommandList = AssociationGroupInfoCC_1.AssociationGroupInfoCC.getIssuedCommandsCached(applHost, endpoint, group);
+    if (!groupCommandList || !groupCommandList.size) {
+        // We don't know which CCs this group controls, just allow it
+        return true;
+    }
+    const groupCCs = [...groupCommandList.keys()];
+    // A controlling node MAY create an association to a destination supporting an
+    // actuator Command Class if the actual association group sends Basic Control Command Class.
+    if (groupCCs.includes(safe_1.CommandClasses.Basic) &&
+        safe_1.actuatorCCs.some((cc) => targetEndpoint === null || targetEndpoint === void 0 ? void 0 : targetEndpoint.supportsCC(cc))) {
+        return true;
+    }
+    // Enforce that at least one issued CC is supported
+    return groupCCs.some((cc) => targetEndpoint === null || targetEndpoint === void 0 ? void 0 : targetEndpoint.supportsCC(cc));
+}
+exports.isAssociationAllowed = isAssociationAllowed;
+function getAssociationGroups(applHost, endpoint) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    // Check whether we have multi channel support or not
+    let assocInstance;
+    let mcInstance;
+    if (endpoint.supportsCC(safe_1.CommandClasses.Association)) {
+        assocInstance = AssociationCC_1.AssociationCC;
+    }
+    else {
+        throw new safe_1.ZWaveError(`Node ${endpoint.nodeId}${endpoint.index > 0 ? `, endpoint ${endpoint.index}` : ""} does not support associations!`, safe_1.ZWaveErrorCodes.CC_NotSupported);
+    }
+    if (endpoint.supportsCC(safe_1.CommandClasses["Multi Channel Association"])) {
+        mcInstance = MultiChannelAssociationCC_1.MultiChannelAssociationCC;
+    }
+    const assocGroupCount = (_a = assocInstance.getGroupCountCached(applHost, endpoint)) !== null && _a !== void 0 ? _a : 0;
+    const mcGroupCount = (_b = mcInstance === null || mcInstance === void 0 ? void 0 : mcInstance.getGroupCountCached(applHost, endpoint)) !== null && _b !== void 0 ? _b : 0;
+    const groupCount = Math.max(assocGroupCount, mcGroupCount);
+    const deviceConfig = (_c = applHost.getDeviceConfig) === null || _c === void 0 ? void 0 : _c.call(applHost, endpoint.nodeId);
+    const ret = new Map();
+    if (endpoint.supportsCC(safe_1.CommandClasses["Association Group Information"])) {
+        // We can read all information we need from the AGI CC
+        const agiInstance = AssociationGroupInfoCC_1.AssociationGroupInfoCC;
+        for (let group = 1; group <= groupCount; group++) {
+            const assocConfig = deviceConfig === null || deviceConfig === void 0 ? void 0 : deviceConfig.getAssociationConfigForEndpoint(endpoint.index, group);
+            const multiChannel = !!mcInstance && group <= mcGroupCount;
+            ret.set(group, {
+                maxNodes: (multiChannel
+                    ? mcInstance
+                    : assocInstance).getMaxNodesCached(applHost, endpoint, group) || 1,
+                // AGI implies Z-Wave+ where group 1 is the lifeline
+                isLifeline: group === 1,
+                label: 
+                // prefer the configured label if we have one
+                (_e = (_d = assocConfig === null || assocConfig === void 0 ? void 0 : assocConfig.label) !== null && _d !== void 0 ? _d : 
+                // the ones reported by AGI are sometimes pretty bad
+                agiInstance.getGroupNameCached(applHost, endpoint, group)) !== null && _e !== void 0 ? _e : 
+                // but still better than "unnamed"
+                `Unnamed group ${group}`,
+                multiChannel,
+                profile: agiInstance.getGroupProfileCached(applHost, endpoint, group),
+                issuedCommands: agiInstance.getIssuedCommandsCached(applHost, endpoint, group),
+            });
+        }
+    }
+    else {
+        // we need to consult the device config
+        for (let group = 1; group <= groupCount; group++) {
+            const assocConfig = deviceConfig === null || deviceConfig === void 0 ? void 0 : deviceConfig.getAssociationConfigForEndpoint(endpoint.index, group);
+            const multiChannel = !!mcInstance && group <= mcGroupCount;
+            ret.set(group, {
+                maxNodes: (multiChannel
+                    ? mcInstance
+                    : assocInstance).getMaxNodesCached(applHost, endpoint, group) ||
+                    (assocConfig === null || assocConfig === void 0 ? void 0 : assocConfig.maxNodes) ||
+                    1,
+                isLifeline: (_f = assocConfig === null || assocConfig === void 0 ? void 0 : assocConfig.isLifeline) !== null && _f !== void 0 ? _f : group === 1,
+                label: (_g = assocConfig === null || assocConfig === void 0 ? void 0 : assocConfig.label) !== null && _g !== void 0 ? _g : `Unnamed group ${group}`,
+                multiChannel,
+            });
+        }
+    }
+    return ret;
+}
+exports.getAssociationGroups = getAssociationGroups;
+function getAllAssociationGroups(applHost, node) {
+    const ret = new Map();
+    for (const endpoint of node.getAllEndpoints()) {
+        if (endpoint.supportsCC(safe_1.CommandClasses.Association)) {
+            ret.set(endpoint.index, getAssociationGroups(applHost, endpoint));
+        }
+    }
+    return ret;
+}
+exports.getAllAssociationGroups = getAllAssociationGroups;
+async function addAssociations(applHost, endpoint, group, destinations) {
+    var _a, _b, _c, _d, _e;
+    const nodeAndEndpointString = `${endpoint.nodeId}${endpoint.index > 0 ? `, endpoint ${endpoint.index}` : ""}`;
+    // Check whether we should add any associations the device does not have support for
+    let assocInstance;
+    let mcInstance;
+    // Split associations into conventional and endpoint associations
+    const nodeAssociations = (0, arrays_1.distinct)(destinations
+        .filter((a) => a.endpoint == undefined)
+        .map((a) => a.nodeId));
+    const endpointAssociations = destinations.filter((a) => a.endpoint != undefined);
+    if (endpoint.supportsCC(safe_1.CommandClasses.Association)) {
+        assocInstance = AssociationCC_1.AssociationCC;
+    }
+    else if (nodeAssociations.length > 0) {
+        throw new safe_1.ZWaveError(`Node ${nodeAndEndpointString} does not support associations!`, safe_1.ZWaveErrorCodes.CC_NotSupported);
+    }
+    if (endpoint.supportsCC(safe_1.CommandClasses["Multi Channel Association"])) {
+        mcInstance = MultiChannelAssociationCC_1.MultiChannelAssociationCC;
+    }
+    else if (endpointAssociations.length > 0) {
+        throw new safe_1.ZWaveError(`Node ${nodeAndEndpointString} does not support multi channel associations!`, safe_1.ZWaveErrorCodes.CC_NotSupported);
+    }
+    const assocGroupCount = (_a = assocInstance === null || assocInstance === void 0 ? void 0 : assocInstance.getGroupCountCached(applHost, endpoint)) !== null && _a !== void 0 ? _a : 0;
+    const mcGroupCount = (_b = mcInstance === null || mcInstance === void 0 ? void 0 : mcInstance.getGroupCountCached(applHost, endpoint)) !== null && _b !== void 0 ? _b : 0;
+    const groupCount = Math.max(assocGroupCount, mcGroupCount);
+    if (group > groupCount) {
+        throw new safe_1.ZWaveError(`Group ${group} does not exist on node ${nodeAndEndpointString}`, safe_1.ZWaveErrorCodes.AssociationCC_InvalidGroup);
+    }
+    const deviceConfig = (_c = applHost.getDeviceConfig) === null || _c === void 0 ? void 0 : _c.call(applHost, endpoint.nodeId);
+    const groupIsMultiChannel = !!mcInstance &&
+        group <= mcGroupCount &&
+        ((_e = (_d = deviceConfig === null || deviceConfig === void 0 ? void 0 : deviceConfig.associations) === null || _d === void 0 ? void 0 : _d.get(group)) === null || _e === void 0 ? void 0 : _e.multiChannel) !== false;
+    if (groupIsMultiChannel) {
+        // Check that all associations are allowed
+        const disallowedAssociations = destinations.filter((a) => !isAssociationAllowed(applHost, endpoint, group, a));
+        if (disallowedAssociations.length) {
+            let message = `The following associations are not allowed:`;
+            message += disallowedAssociations
+                .map((a) => `\n· Node ${a.nodeId}${a.endpoint ? `, endpoint ${a.endpoint}` : ""}`)
+                .join("");
+            throw new safe_1.ZWaveError(message, safe_1.ZWaveErrorCodes.AssociationCC_NotAllowed);
+        }
+        // And add them
+        const api = API_1.CCAPI.create(safe_1.CommandClasses["Multi Channel Association"], applHost, endpoint);
+        await api.addDestinations({
+            groupId: group,
+            nodeIds: nodeAssociations,
+            endpoints: endpointAssociations,
+        });
+        // Refresh the association list
+        await api.getGroup(group);
+    }
+    else {
+        // Although the node supports multi channel associations, this group only supports "normal" associations
+        if (destinations.some((a) => a.endpoint != undefined)) {
+            throw new safe_1.ZWaveError(`Node ${nodeAndEndpointString}, group ${group} does not support multi channel associations!`, safe_1.ZWaveErrorCodes.CC_NotSupported);
+        }
+        // Check that all associations are allowed
+        const disallowedAssociations = destinations.filter((a) => !isAssociationAllowed(applHost, endpoint, group, a));
+        if (disallowedAssociations.length) {
+            throw new safe_1.ZWaveError(`The associations to the following nodes are not allowed: ${disallowedAssociations
+                .map((a) => a.nodeId)
+                .join(", ")}`, safe_1.ZWaveErrorCodes.AssociationCC_NotAllowed);
+        }
+        const api = API_1.CCAPI.create(safe_1.CommandClasses.Association, applHost, endpoint);
+        await api.addNodeIds(group, ...destinations.map((a) => a.nodeId));
+        // Refresh the association list
+        await api.getGroup(group);
+    }
+}
+exports.addAssociations = addAssociations;
+async function removeAssociations(applHost, endpoint, group, destinations) {
+    const nodeAndEndpointString = `${endpoint.nodeId}${endpoint.index > 0 ? `, endpoint ${endpoint.index}` : ""}`;
+    // Split associations into conventional and endpoint associations
+    const nodeAssociations = (0, arrays_1.distinct)(destinations
+        .filter((a) => a.endpoint == undefined)
+        .map((a) => a.nodeId));
+    const endpointAssociations = destinations.filter((a) => a.endpoint != undefined);
+    // Removing associations is not either/or - we could have a device with duplicated associations between
+    // Association CC and Multi Channel Association CC
+    // Figure out what we need to use to remove the associations
+    let groupExistsAsMultiChannel = false;
+    let groupExistsAsNodeAssociation = false;
+    let mcInstance;
+    let assocInstance;
+    // To remove a multi channel association, we need to make sure that the group exists
+    // and the node supports multi channel associations
+    if (endpoint.supportsCC(safe_1.CommandClasses["Multi Channel Association"])) {
+        mcInstance = MultiChannelAssociationCC_1.MultiChannelAssociationCC;
+        if (group <= mcInstance.getGroupCountCached(applHost, endpoint)) {
+            groupExistsAsMultiChannel = true;
+        }
+    }
+    else if (endpointAssociations.length > 0) {
+        throw new safe_1.ZWaveError(`Node ${nodeAndEndpointString} does not support multi channel associations!`, safe_1.ZWaveErrorCodes.CC_NotSupported);
+    }
+    // To remove a normal association, we need to make sure that the group exists either as a normal association
+    // or as a multi channel association
+    if (endpoint.supportsCC(safe_1.CommandClasses.Association)) {
+        assocInstance = AssociationCC_1.AssociationCC;
+        if (group <= assocInstance.getGroupCountCached(applHost, endpoint)) {
+            groupExistsAsNodeAssociation = true;
+        }
+    }
+    if (!mcInstance && !assocInstance) {
+        throw new safe_1.ZWaveError(`Node ${nodeAndEndpointString} does not support associations!`, safe_1.ZWaveErrorCodes.CC_NotSupported);
+    }
+    // Ensure the group exists and can be used
+    if (!groupExistsAsMultiChannel && !groupExistsAsNodeAssociation) {
+        throw new safe_1.ZWaveError(` Association group ${group} does not exist for node ${nodeAndEndpointString}`, safe_1.ZWaveErrorCodes.AssociationCC_InvalidGroup);
+    }
+    if (endpointAssociations.length > 0 && !groupExistsAsMultiChannel) {
+        throw new safe_1.ZWaveError(`Node ${nodeAndEndpointString}, association group ${group} does not support multi channel associations!`, safe_1.ZWaveErrorCodes.AssociationCC_InvalidGroup);
+    }
+    // Even if we only remove node associations, we use both CCs since it has been found that some
+    // devices do not correctly share the node list between the two commands
+    if (assocInstance &&
+        nodeAssociations.length > 0 &&
+        groupExistsAsNodeAssociation) {
+        const api = API_1.CCAPI.create(safe_1.CommandClasses.Association, applHost, endpoint);
+        await api.removeNodeIds({
+            groupId: group,
+            nodeIds: nodeAssociations,
+        });
+        // Refresh the association list
+        await api.getGroup(group);
+    }
+    if (mcInstance && groupExistsAsMultiChannel) {
+        const api = API_1.CCAPI.create(safe_1.CommandClasses["Multi Channel Association"], applHost, endpoint);
+        await api.removeDestinations({
+            groupId: group,
+            nodeIds: nodeAssociations,
+            endpoints: endpointAssociations,
+        });
+        // Refresh the multi channel association list
+        await api.getGroup(group);
+    }
+}
+exports.removeAssociations = removeAssociations;
+async function configureLifelineAssociations(applHost, endpoint) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    // Assign the controller to all lifeline groups
+    const ownNodeId = applHost.ownNodeId;
+    const node = endpoint.getNodeUnsafe();
+    const valueDB = applHost.getValueDB(node.id);
+    const deviceConfig = (_a = applHost.getDeviceConfig) === null || _a === void 0 ? void 0 : _a.call(applHost, node.id);
+    // We check if a node supports Multi Channel CC before creating Multi Channel Lifeline Associations (#1109)
+    const nodeSupportsMultiChannel = node.supportsCC(safe_1.CommandClasses["Multi Channel"]);
+    let assocInstance;
+    const assocAPI = API_1.CCAPI.create(safe_1.CommandClasses.Association, applHost, endpoint);
+    if (endpoint.supportsCC(safe_1.CommandClasses.Association)) {
+        assocInstance = AssociationCC_1.AssociationCC;
+    }
+    let mcInstance;
+    let mcGroupCount = 0;
+    const mcAPI = API_1.CCAPI.create(safe_1.CommandClasses["Multi Channel Association"], applHost, endpoint);
+    if (endpoint.supportsCC(safe_1.CommandClasses["Multi Channel Association"])) {
+        mcInstance = MultiChannelAssociationCC_1.MultiChannelAssociationCC;
+        mcGroupCount = (_b = mcInstance.getGroupCountCached(applHost, endpoint)) !== null && _b !== void 0 ? _b : 0;
+    }
+    const lifelineGroups = (0, AssociationCC_1.getLifelineGroupIds)(applHost, node);
+    if (lifelineGroups.length === 0) {
+        applHost.controllerLog.logNode(node.id, {
+            endpoint: endpoint.index,
+            message: "No information about Lifeline associations, cannot assign ourselves!",
+            level: "warn",
+        });
+        // Remember that we have NO lifeline association
+        valueDB.setValue((0, AssociationCC_1.getHasLifelineValueId)(endpoint.index), false);
+        return;
+    }
+    applHost.controllerLog.logNode(node.id, {
+        endpoint: endpoint.index,
+        message: `Checking/assigning lifeline groups: ${lifelineGroups.join(", ")}
+supports classic associations:       ${!!assocInstance}
+supports multi channel associations: ${!!mcInstance}`,
+    });
+    for (const group of lifelineGroups) {
+        const groupSupportsMultiChannelAssociation = group <= mcGroupCount;
+        const assocConfig = deviceConfig === null || deviceConfig === void 0 ? void 0 : deviceConfig.getAssociationConfigForEndpoint(endpoint.index, group);
+        const mustUseNodeAssociation = !groupSupportsMultiChannelAssociation ||
+            !nodeSupportsMultiChannel ||
+            (assocConfig === null || assocConfig === void 0 ? void 0 : assocConfig.multiChannel) === false;
+        let mustUseMultiChannelAssociation = false;
+        if (groupSupportsMultiChannelAssociation && nodeSupportsMultiChannel) {
+            if ((assocConfig === null || assocConfig === void 0 ? void 0 : assocConfig.multiChannel) === true) {
+                mustUseMultiChannelAssociation = true;
+            }
+            else if (endpoint.index === 0) {
+                // If the node has multiple endpoints but none of the extra ones support associations,
+                // the root endpoints needs a Multi Channel Association
+                const allEndpoints = node.getAllEndpoints();
+                if (allEndpoints.length > 1 &&
+                    allEndpoints
+                        .filter((e) => e.index !== endpoint.index)
+                        .every((e) => !e.supportsCC(safe_1.CommandClasses.Association) &&
+                        !e.supportsCC(safe_1.CommandClasses["Multi Channel Association"]))) {
+                    mustUseMultiChannelAssociation = true;
+                }
+            }
+        }
+        applHost.controllerLog.logNode(node.id, {
+            endpoint: endpoint.index,
+            message: `Configuring lifeline group #${group}:
+group supports multi channel:  ${groupSupportsMultiChannelAssociation}
+configured strategy:           ${(_c = assocConfig === null || assocConfig === void 0 ? void 0 : assocConfig.multiChannel) !== null && _c !== void 0 ? _c : "auto"}
+must use node association:     ${mustUseNodeAssociation}
+must use endpoint association: ${mustUseMultiChannelAssociation}`,
+        });
+        // Figure out which associations exist and may need to be removed
+        const isAssignedAsNodeAssociation = () => {
+            var _a, _b;
+            if (groupSupportsMultiChannelAssociation && mcInstance) {
+                if (
+                // Only consider a group if it doesn't share its associations with the root endpoint
+                mcInstance.getMaxNodesCached(applHost, endpoint, group) >
+                    0 &&
+                    !!((_a = mcInstance
+                        .getAllDestinationsCached(applHost, endpoint)
+                        .get(group)) === null || _a === void 0 ? void 0 : _a.some((addr) => addr.nodeId === ownNodeId &&
+                        addr.endpoint == undefined))) {
+                    return true;
+                }
+            }
+            if (assocInstance) {
+                if (
+                // Only consider a group if it doesn't share its associations with the root endpoint
+                assocInstance.getMaxNodesCached(applHost, endpoint, group) >
+                    0 &&
+                    !!((_b = assocInstance
+                        .getAllDestinationsCached(applHost, endpoint)
+                        .get(group)) === null || _b === void 0 ? void 0 : _b.some((addr) => addr.nodeId === ownNodeId))) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        const isAssignedAsEndpointAssociation = () => {
+            var _a;
+            if (mcInstance) {
+                if (
+                // Only consider a group if it doesn't share its associations with the root endpoint
+                mcInstance.getMaxNodesCached(applHost, endpoint, group) >
+                    0 &&
+                    ((_a = mcInstance
+                        .getAllDestinationsCached(applHost, endpoint)
+                        .get(group)) === null || _a === void 0 ? void 0 : _a.some((addr) => addr.nodeId === ownNodeId &&
+                        addr.endpoint === 0))) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        // If the node was used with other controller softwares, there might be
+        // invalid lifeline associations which cause reporting problems
+        const invalidEndpointAssociations = (_e = (_d = mcInstance === null || mcInstance === void 0 ? void 0 : mcInstance.getAllDestinationsCached(applHost, endpoint).get(group)) === null || _d === void 0 ? void 0 : _d.filter((addr) => addr.nodeId === ownNodeId &&
+            addr.endpoint != undefined &&
+            addr.endpoint !== 0)) !== null && _e !== void 0 ? _e : [];
+        // Clean them up first
+        if (invalidEndpointAssociations.length > 0 &&
+            mcAPI.isSupported() &&
+            groupSupportsMultiChannelAssociation) {
+            applHost.controllerLog.logNode(node.id, {
+                endpoint: endpoint.index,
+                message: `Found invalid lifeline associations in group #${group}, removing them...`,
+                direction: "outbound",
+            });
+            await mcAPI.removeDestinations({
+                groupId: group,
+                endpoints: invalidEndpointAssociations,
+            });
+            // refresh the associations - don't trust that it worked
+            await mcAPI.getGroup(group);
+        }
+        // Assigning the correct lifelines depends on the association kind, source endpoint and the desired strategy:
+        //
+        // When `mustUseMultiChannelAssociation` is `true` - Use a multi channel association (if possible), no fallback
+        // When `mustUseNodeAssociation` is `true` - Use a node association (if possible), no fallback
+        // Otherwise:
+        //   1. Try a node association on the current endpoint/root
+        //   2. If Association CC is not supported, try assigning a node association with the Multi Channel Association CC
+        //   3. If that did not work, fall back to a multi channel association (target endpoint 0)
+        //   4. If that did not work either, the endpoint index is >0 and the node is Z-Wave+:
+        //      Fall back to a multi channel association (target endpoint 0) on the root, if it doesn't have one yet.
+        let hasLifeline = false;
+        // First try: node association
+        if (!mustUseMultiChannelAssociation) {
+            if (isAssignedAsNodeAssociation()) {
+                // We already have the correct association
+                hasLifeline = true;
+                applHost.controllerLog.logNode(node.id, {
+                    endpoint: endpoint.index,
+                    message: `Lifeline group #${group} is already assigned with a node association`,
+                    direction: "none",
+                });
+            }
+            else if (assocAPI.isSupported() &&
+                // Some endpoint groups don't support having any destinations because they are shared with the root
+                assocInstance.getMaxNodesCached(applHost, endpoint, group) > 0) {
+                // We can use a node association, but first remove any possible endpoint associations
+                applHost.controllerLog.logNode(node.id, {
+                    endpoint: endpoint.index,
+                    message: `Assigning lifeline group #${group} with a node association via Association CC...`,
+                    direction: "outbound",
+                });
+                if (isAssignedAsEndpointAssociation() && mcAPI.isSupported()) {
+                    await mcAPI.removeDestinations({
+                        groupId: group,
+                        endpoints: [{ nodeId: ownNodeId, endpoint: 0 }],
+                    });
+                    // refresh the associations - don't trust that it worked
+                    await mcAPI.getGroup(group);
+                }
+                await assocAPI.addNodeIds(group, ownNodeId);
+                // refresh the associations - don't trust that it worked
+                const groupReport = await assocAPI.getGroup(group);
+                hasLifeline = !!(groupReport === null || groupReport === void 0 ? void 0 : groupReport.nodeIds.includes(ownNodeId));
+                if (hasLifeline) {
+                    applHost.controllerLog.logNode(node.id, {
+                        endpoint: endpoint.index,
+                        message: `Lifeline group #${group} was assigned with a node association via Association CC`,
+                        direction: "none",
+                    });
+                }
+                else {
+                    applHost.controllerLog.logNode(node.id, {
+                        endpoint: endpoint.index,
+                        message: `Assigning lifeline group #${group} with a node association via Association CC did not work`,
+                        direction: "none",
+                    });
+                }
+            }
+            // Second try: Node association using the Multi Channel Association CC
+            if (!hasLifeline &&
+                mcAPI.isSupported() &&
+                mcInstance.getMaxNodesCached(applHost, endpoint, group) > 0) {
+                // We can use a node association, but first remove any possible endpoint associations
+                applHost.controllerLog.logNode(node.id, {
+                    endpoint: endpoint.index,
+                    message: `Assigning lifeline group #${group} with a node association via Multi Channel Association CC...`,
+                    direction: "outbound",
+                });
+                if (isAssignedAsEndpointAssociation()) {
+                    await mcAPI.removeDestinations({
+                        groupId: group,
+                        endpoints: [{ nodeId: ownNodeId, endpoint: 0 }],
+                    });
+                }
+                await mcAPI.addDestinations({
+                    groupId: group,
+                    nodeIds: [ownNodeId],
+                });
+                // refresh the associations - don't trust that it worked
+                const groupReport = await mcAPI.getGroup(group);
+                hasLifeline = !!(groupReport === null || groupReport === void 0 ? void 0 : groupReport.nodeIds.includes(ownNodeId));
+                if (hasLifeline) {
+                    applHost.controllerLog.logNode(node.id, {
+                        endpoint: endpoint.index,
+                        message: `Lifeline group #${group} was assigned with a node association via Multi Channel Association CC`,
+                        direction: "none",
+                    });
+                }
+                else {
+                    applHost.controllerLog.logNode(node.id, {
+                        endpoint: endpoint.index,
+                        message: `Assigning lifeline group #${group} with a node association via Multi Channel Association CC did not work`,
+                        direction: "none",
+                    });
+                }
+            }
+        }
+        // Third try: Use an endpoint association (target endpoint 0)
+        // This is only supported starting in Multi Channel Association CC V3
+        if (!hasLifeline && !mustUseNodeAssociation) {
+            if (isAssignedAsEndpointAssociation()) {
+                // We already have the correct association
+                hasLifeline = true;
+                applHost.controllerLog.logNode(node.id, {
+                    endpoint: endpoint.index,
+                    message: `Lifeline group #${group} is already assigned with an endpoint association`,
+                    direction: "none",
+                });
+            }
+            else if (mcAPI.isSupported() &&
+                mcAPI.version >= 3 &&
+                mcInstance.getMaxNodesCached(applHost, endpoint, group) > 0) {
+                // We can use a multi channel association, but first remove any possible node associations
+                applHost.controllerLog.logNode(node.id, {
+                    endpoint: endpoint.index,
+                    message: `Assigning lifeline group #${group} with a multi channel association...`,
+                    direction: "outbound",
+                });
+                if (isAssignedAsNodeAssociation()) {
+                    // It has been found that some devices don't correctly share the node associations between
+                    // Association CC and Multi Channel Association CC, so we remove the nodes from both lists
+                    await mcAPI.removeDestinations({
+                        groupId: group,
+                        nodeIds: [ownNodeId],
+                    });
+                    if (assocAPI.isSupported()) {
+                        await assocAPI.removeNodeIds({
+                            groupId: group,
+                            nodeIds: [ownNodeId],
+                        });
+                        // refresh the associations - don't trust that it worked
+                        await assocAPI.getGroup(group);
+                    }
+                }
+                await mcAPI.addDestinations({
+                    groupId: group,
+                    endpoints: [{ nodeId: ownNodeId, endpoint: 0 }],
+                });
+                // refresh the associations - don't trust that it worked
+                const groupReport = await mcAPI.getGroup(group);
+                hasLifeline = !!(groupReport === null || groupReport === void 0 ? void 0 : groupReport.endpoints.some((a) => a.nodeId === ownNodeId && a.endpoint === 0));
+                if (hasLifeline) {
+                    applHost.controllerLog.logNode(node.id, {
+                        endpoint: endpoint.index,
+                        message: `Lifeline group #${group} was assigned with a multi channel association`,
+                        direction: "none",
+                    });
+                }
+                else {
+                    applHost.controllerLog.logNode(node.id, {
+                        endpoint: endpoint.index,
+                        message: `Assigning lifeline group #${group} with a multi channel association did not work`,
+                        direction: "none",
+                    });
+                }
+            }
+        }
+        // Last attempt (actual Z-Wave+ Lifelines only): Try a multi channel association on the root.
+        // Endpoint interviews happen AFTER the root interview, so this enables us to overwrite what
+        // we previously configured on the root.
+        if (!hasLifeline &&
+            group === 1 &&
+            node.supportsCC(safe_1.CommandClasses["Z-Wave Plus Info"]) &&
+            endpoint.index > 0) {
+            // But first check if the root may have a multi channel association
+            const rootAssocConfig = deviceConfig === null || deviceConfig === void 0 ? void 0 : deviceConfig.getAssociationConfigForEndpoint(0, group);
+            const rootMustUseNodeAssociation = !nodeSupportsMultiChannel ||
+                (rootAssocConfig === null || rootAssocConfig === void 0 ? void 0 : rootAssocConfig.multiChannel) === false;
+            applHost.controllerLog.logNode(node.id, {
+                endpoint: endpoint.index,
+                message: `Checking root device for fallback assignment of lifeline group #${group}:
+root supports multi channel:  ${nodeSupportsMultiChannel}
+configured strategy:           ${(_f = rootAssocConfig === null || rootAssocConfig === void 0 ? void 0 : rootAssocConfig.multiChannel) !== null && _f !== void 0 ? _f : "auto"}
+must use node association:     ${rootMustUseNodeAssociation}`,
+            });
+            if (!rootMustUseNodeAssociation) {
+                const rootNodesValueId = (0, MultiChannelAssociationCC_1.getNodeIdsValueId)(0, group);
+                const rootHasNodeAssociation = !!((_g = valueDB
+                    .getValue(rootNodesValueId)) === null || _g === void 0 ? void 0 : _g.some((a) => a === ownNodeId));
+                const rootEndpointsValueId = (0, MultiChannelAssociationCC_1.getEndpointsValueId)(0, group);
+                const rootHasEndpointAssociation = !!((_h = valueDB
+                    .getValue(rootEndpointsValueId)) === null || _h === void 0 ? void 0 : _h.some((a) => a.nodeId === ownNodeId && a.endpoint === 0));
+                if (rootHasEndpointAssociation) {
+                    // We already have the correct association
+                    hasLifeline = true;
+                    applHost.controllerLog.logNode(node.id, {
+                        endpoint: endpoint.index,
+                        message: `Lifeline group #${group} is already assigned with a multi channel association on the root device`,
+                        direction: "none",
+                    });
+                }
+                else {
+                    const rootMCAPI = API_1.CCAPI.create(safe_1.CommandClasses["Multi Channel Association"], applHost, node);
+                    if (rootMCAPI.isSupported()) {
+                        applHost.controllerLog.logNode(node.id, {
+                            endpoint: endpoint.index,
+                            message: `Assigning lifeline group #${group} with a multi channel association on the root device...`,
+                            direction: "outbound",
+                        });
+                        // Clean up node associations because they might prevent us from adding the endpoint association
+                        if (rootHasNodeAssociation) {
+                            await rootMCAPI.removeDestinations({
+                                groupId: group,
+                                nodeIds: [ownNodeId],
+                            });
+                        }
+                        await rootMCAPI.addDestinations({
+                            groupId: group,
+                            endpoints: [{ nodeId: ownNodeId, endpoint: 0 }],
+                        });
+                        // refresh the associations - don't trust that it worked
+                        const groupReport = await rootMCAPI.getGroup(group);
+                        hasLifeline = !!(groupReport === null || groupReport === void 0 ? void 0 : groupReport.endpoints.some((a) => a.nodeId === ownNodeId && a.endpoint === 0));
+                    }
+                }
+            }
+        }
+        if (!hasLifeline) {
+            applHost.controllerLog.logNode(node.id, {
+                endpoint: endpoint.index,
+                message: `All attempts to assign lifeline group #${group} failed, skipping...`,
+                direction: "none",
+                level: "warn",
+            });
+        }
+    }
+    // Remember that we did the association assignment
+    valueDB.setValue((0, AssociationCC_1.getHasLifelineValueId)(endpoint.index), true);
+}
+exports.configureLifelineAssociations = configureLifelineAssociations;
+//# sourceMappingURL=utils.js.map