@zwave-js/cc 15.1.1 → 15.1.2

package/build/cjs/lib/utils.js

@@ -32,8 +32,8 @@ __export(utils_exports, {
   removeAssociations: () => removeAssociations
 });
 module.exports = __toCommonJS(utils_exports);
-var import_safe = require("@zwave-js/core/safe");
-var import_safe2 = require("@zwave-js/shared/safe");
+var import_core = require("@zwave-js/core");
+var import_shared = require("@zwave-js/shared");
 var import_arrays = require("alcalzone-shared/arrays");
 var import_AssociationCC = require("../cc/AssociationCC.js");
 var import_AssociationGroupInfoCC = require("../cc/AssociationGroupInfoCC.js");
@@ -42,15 +42,15 @@ var import_API = require("./API.js");
 var import_Types = require("./_Types.js");
 function getAssociations(ctx, endpoint) {
   const ret = /* @__PURE__ */ new Map();
-  if (endpoint.supportsCC(import_safe.CommandClasses.Association)) {
+  if (endpoint.supportsCC(import_core.CommandClasses.Association)) {
     const destinations = import_AssociationCC.AssociationCC.getAllDestinationsCached(ctx, endpoint);
     for (const [groupId, assocs] of destinations) {
       ret.set(groupId, assocs);
     }
   } else {
-    throw new import_safe.ZWaveError(`Node ${endpoint.nodeId}${endpoint.index > 0 ? `, endpoint ${endpoint.index}` : ""} does not support associations!`, import_safe.ZWaveErrorCodes.CC_NotSupported);
+    throw new import_core.ZWaveError(`Node ${endpoint.nodeId}${endpoint.index > 0 ? `, endpoint ${endpoint.index}` : ""} does not support associations!`, import_core.ZWaveErrorCodes.CC_NotSupported);
   }
-  if (endpoint.supportsCC(import_safe.CommandClasses["Multi Channel Association"])) {
+  if (endpoint.supportsCC(import_core.CommandClasses["Multi Channel Association"])) {
     const destinations = import_MultiChannelAssociationCC.MultiChannelAssociationCC.getAllDestinationsCached(ctx, endpoint);
     for (const [groupId, assocs] of destinations) {
       if (ret.has(groupId)) {
@@ -69,13 +69,13 @@ function getAssociations(ctx, endpoint) {
 }
 __name(getAssociations, "getAssociations");
 function getAllAssociations(ctx, node) {
-  const ret = new import_safe2.ObjectKeyMap();
+  const ret = new import_shared.ObjectKeyMap();
   for (const endpoint of node.getAllEndpoints()) {
     const address = {
       nodeId: node.id,
       endpoint: endpoint.index
     };
-    if (endpoint.supportsCC(import_safe.CommandClasses.Association)) {
+    if (endpoint.supportsCC(import_core.CommandClasses.Association)) {
       ret.set(address, getAssociations(ctx, endpoint));
     }
   }
@@ -85,12 +85,12 @@ __name(getAllAssociations, "getAllAssociations");
 function checkAssociation(ctx, endpoint, group, destination) {
   const targetNode = ctx.getNodeOrThrow(destination.nodeId);
   const targetEndpoint = destination.nodeId === ctx.ownNodeId ? targetNode : targetNode.getEndpointOrThrow(destination.endpoint ?? 0);
-  if (!endpoint.supportsCC(import_safe.CommandClasses.Association) && !endpoint.supportsCC(import_safe.CommandClasses["Multi Channel Association"])) {
-    throw new import_safe.ZWaveError(`Node ${endpoint.nodeId}${endpoint.index > 0 ? `, endpoint ${endpoint.index}` : ""} does not support associations!`, import_safe.ZWaveErrorCodes.CC_NotSupported);
+  if (!endpoint.supportsCC(import_core.CommandClasses.Association) && !endpoint.supportsCC(import_core.CommandClasses["Multi Channel Association"])) {
+    throw new import_core.ZWaveError(`Node ${endpoint.nodeId}${endpoint.index > 0 ? `, endpoint ${endpoint.index}` : ""} does not support associations!`, import_core.ZWaveErrorCodes.CC_NotSupported);
   }
-  if ((0, import_safe.isLongRangeNodeId)(destination.nodeId)) {
+  if ((0, import_core.isLongRangeNodeId)(destination.nodeId)) {
     return import_Types.AssociationCheckResult.Forbidden_DestinationIsLongRange;
-  } else if ((0, import_safe.isLongRangeNodeId)(endpoint.nodeId)) {
+  } else if ((0, import_core.isLongRangeNodeId)(endpoint.nodeId)) {
     if (group !== 1 || destination.nodeId !== ctx.ownNodeId) {
       return import_Types.AssociationCheckResult.Forbidden_SourceIsLongRange;
     }
@@ -104,10 +104,10 @@ function checkAssociation(ctx, endpoint, group, destination) {
   const sourceNode = ctx.getNode(endpoint.nodeId);
   let securityClassMustMatch;
   if (destination.endpoint == void 0) {
-    const sourceNodeCCVersion = endpoint.getCCVersion(import_safe.CommandClasses.Association);
+    const sourceNodeCCVersion = endpoint.getCCVersion(import_core.CommandClasses.Association);
     securityClassMustMatch = sourceNodeCCVersion < 3;
   } else {
-    const sourceNodeCCVersion = endpoint.getCCVersion(import_safe.CommandClasses["Multi Channel Association"]);
+    const sourceNodeCCVersion = endpoint.getCCVersion(import_core.CommandClasses["Multi Channel Association"]);
     securityClassMustMatch = sourceNodeCCVersion < 4;
   }
   const sourceSecurityClass = sourceNode.getHighestSecurityClass();
@@ -117,12 +117,12 @@ function checkAssociation(ctx, endpoint, group, destination) {
       return import_Types.AssociationCheckResult.Forbidden_SecurityClassMismatch;
     } else if (
       // Commands to insecure nodes are allowed
-      targetSecurityClass !== import_safe.SecurityClass.None && !securityClassMustMatch && !sourceNode.hasSecurityClass(targetSecurityClass)
+      targetSecurityClass !== import_core.SecurityClass.None && !securityClassMustMatch && !sourceNode.hasSecurityClass(targetSecurityClass)
     ) {
       return import_Types.AssociationCheckResult.Forbidden_DestinationSecurityClassNotGranted;
     }
   }
-  if (!endpoint.supportsCC(import_safe.CommandClasses["Association Group Information"])) {
+  if (!endpoint.supportsCC(import_core.CommandClasses["Association Group Information"])) {
     return import_Types.AssociationCheckResult.OK;
   }
   const groupCommandList = import_AssociationGroupInfoCC.AssociationGroupInfoCC.getIssuedCommandsCached(ctx, endpoint, group);
@@ -130,7 +130,7 @@ function checkAssociation(ctx, endpoint, group, destination) {
     return import_Types.AssociationCheckResult.OK;
   }
   const groupCCs = [...groupCommandList.keys()];
-  if (groupCCs.includes(import_safe.CommandClasses.Basic) && import_safe.actuatorCCs.some((cc) => targetEndpoint?.supportsCC(cc))) {
+  if (groupCCs.includes(import_core.CommandClasses.Basic) && import_core.actuatorCCs.some((cc) => targetEndpoint?.supportsCC(cc))) {
     return import_Types.AssociationCheckResult.OK;
   }
   if (groupCCs.some((cc) => targetEndpoint?.supportsCC(cc))) {
@@ -143,12 +143,12 @@ __name(checkAssociation, "checkAssociation");
 function getAssociationGroups(ctx, endpoint) {
   let assocInstance;
   let mcInstance;
-  if (endpoint.supportsCC(import_safe.CommandClasses.Association)) {
+  if (endpoint.supportsCC(import_core.CommandClasses.Association)) {
     assocInstance = import_AssociationCC.AssociationCC;
   } else {
-    throw new import_safe.ZWaveError(`Node ${endpoint.nodeId}${endpoint.index > 0 ? `, endpoint ${endpoint.index}` : ""} does not support associations!`, import_safe.ZWaveErrorCodes.CC_NotSupported);
+    throw new import_core.ZWaveError(`Node ${endpoint.nodeId}${endpoint.index > 0 ? `, endpoint ${endpoint.index}` : ""} does not support associations!`, import_core.ZWaveErrorCodes.CC_NotSupported);
   }
-  if (endpoint.supportsCC(import_safe.CommandClasses["Multi Channel Association"])) {
+  if (endpoint.supportsCC(import_core.CommandClasses["Multi Channel Association"])) {
     mcInstance = import_MultiChannelAssociationCC.MultiChannelAssociationCC;
   }
   const assocGroupCount = assocInstance.getGroupCountCached(ctx, endpoint) ?? 0;
@@ -156,7 +156,7 @@ function getAssociationGroups(ctx, endpoint) {
   const groupCount = Math.max(assocGroupCount, mcGroupCount);
   const deviceConfig = ctx.getDeviceConfig?.(endpoint.nodeId);
   const ret = /* @__PURE__ */ new Map();
-  if (endpoint.supportsCC(import_safe.CommandClasses["Association Group Information"])) {
+  if (endpoint.supportsCC(import_core.CommandClasses["Association Group Information"])) {
     const agiInstance = import_AssociationGroupInfoCC.AssociationGroupInfoCC;
     for (let group = 1; group <= groupCount; group++) {
       const assocConfig = deviceConfig?.getAssociationConfigForEndpoint(endpoint.index, group);
@@ -192,7 +192,7 @@ __name(getAssociationGroups, "getAssociationGroups");
 function getAllAssociationGroups(ctx, node) {
   const ret = /* @__PURE__ */ new Map();
   for (const endpoint of node.getAllEndpoints()) {
-    if (endpoint.supportsCC(import_safe.CommandClasses.Association)) {
+    if (endpoint.supportsCC(import_core.CommandClasses.Association)) {
       ret.set(endpoint.index, getAssociationGroups(ctx, endpoint));
     }
   }
@@ -205,19 +205,19 @@ async function addAssociations(ctx, endpoint, group, destinations) {
   let mcInstance;
   const nodeAssociations = (0, import_arrays.distinct)(destinations.filter((a) => a.endpoint == void 0).map((a) => a.nodeId));
   const endpointAssociations = destinations.filter((a) => a.endpoint != void 0);
-  if (endpoint.supportsCC(import_safe.CommandClasses.Association)) {
+  if (endpoint.supportsCC(import_core.CommandClasses.Association)) {
     assocInstance = import_AssociationCC.AssociationCC;
   } else if (nodeAssociations.length > 0) {
-    throw new import_safe.ZWaveError(`Node ${nodeAndEndpointString} does not support associations!`, import_safe.ZWaveErrorCodes.CC_NotSupported);
+    throw new import_core.ZWaveError(`Node ${nodeAndEndpointString} does not support associations!`, import_core.ZWaveErrorCodes.CC_NotSupported);
   }
-  if (endpoint.supportsCC(import_safe.CommandClasses["Multi Channel Association"])) {
+  if (endpoint.supportsCC(import_core.CommandClasses["Multi Channel Association"])) {
     mcInstance = import_MultiChannelAssociationCC.MultiChannelAssociationCC;
   } else if (endpointAssociations.length > 0) {
-    throw new import_safe.ZWaveError(`Node ${nodeAndEndpointString} does not support multi channel associations!`, import_safe.ZWaveErrorCodes.CC_NotSupported);
+    throw new import_core.ZWaveError(`Node ${nodeAndEndpointString} does not support multi channel associations!`, import_core.ZWaveErrorCodes.CC_NotSupported);
   }
   const selfAssociations = destinations.filter((d) => d.nodeId === endpoint.nodeId);
   if (selfAssociations.length > 0) {
-    throw new import_safe.ZWaveError(`Associating a node with itself is not allowed!`, import_safe.ZWaveErrorCodes.AssociationCC_NotAllowed, selfAssociations.map((a) => ({
+    throw new import_core.ZWaveError(`Associating a node with itself is not allowed!`, import_core.ZWaveErrorCodes.AssociationCC_NotAllowed, selfAssociations.map((a) => ({
       ...a,
       checkResult: import_Types.AssociationCheckResult.Forbidden_SelfAssociation
     })));
@@ -226,7 +226,7 @@ async function addAssociations(ctx, endpoint, group, destinations) {
   const mcGroupCount = mcInstance?.getGroupCountCached(ctx, endpoint) ?? 0;
   const groupCount = Math.max(assocGroupCount, mcGroupCount);
   if (group > groupCount) {
-    throw new import_safe.ZWaveError(`Group ${group} does not exist on node ${nodeAndEndpointString}`, import_safe.ZWaveErrorCodes.AssociationCC_InvalidGroup);
+    throw new import_core.ZWaveError(`Group ${group} does not exist on node ${nodeAndEndpointString}`, import_core.ZWaveErrorCodes.AssociationCC_InvalidGroup);
   }
   const deviceConfig = ctx.getDeviceConfig?.(endpoint.nodeId);
   const groupIsMultiChannel = !!mcInstance && group <= mcGroupCount && deviceConfig?.associations?.get(group)?.multiChannel !== false;
@@ -238,10 +238,10 @@ async function addAssociations(ctx, endpoint, group, destinations) {
     if (disallowedAssociations.length) {
       let message = `The following associations are not allowed:`;
       message += disallowedAssociations.map((a) => `
-\xB7 Node ${a.nodeId}${a.endpoint ? `, endpoint ${a.endpoint}` : ""}: ${(0, import_safe2.getEnumMemberName)(import_Types.AssociationCheckResult, a.checkResult).replace("Forbidden_", "")}`).join("");
-      throw new import_safe.ZWaveError(message, import_safe.ZWaveErrorCodes.AssociationCC_NotAllowed, disallowedAssociations);
+\xB7 Node ${a.nodeId}${a.endpoint ? `, endpoint ${a.endpoint}` : ""}: ${(0, import_shared.getEnumMemberName)(import_Types.AssociationCheckResult, a.checkResult).replace("Forbidden_", "")}`).join("");
+      throw new import_core.ZWaveError(message, import_core.ZWaveErrorCodes.AssociationCC_NotAllowed, disallowedAssociations);
     }
-    const api = import_API.CCAPI.create(import_safe.CommandClasses["Multi Channel Association"], ctx, endpoint);
+    const api = import_API.CCAPI.create(import_core.CommandClasses["Multi Channel Association"], ctx, endpoint);
     await api.addDestinations({
       groupId: group,
       nodeIds: nodeAssociations,
@@ -250,7 +250,7 @@ async function addAssociations(ctx, endpoint, group, destinations) {
     await api.getGroup(group);
   } else {
     if (destinations.some((a) => a.endpoint != void 0)) {
-      throw new import_safe.ZWaveError(`Node ${nodeAndEndpointString}, group ${group} does not support multi channel associations!`, import_safe.ZWaveErrorCodes.CC_NotSupported);
+      throw new import_core.ZWaveError(`Node ${nodeAndEndpointString}, group ${group} does not support multi channel associations!`, import_core.ZWaveErrorCodes.CC_NotSupported);
     }
     const disallowedAssociations = destinations.map((a) => ({
       ...a,
@@ -259,10 +259,10 @@ async function addAssociations(ctx, endpoint, group, destinations) {
     if (disallowedAssociations.length) {
       let message = `The associations to the following nodes are not allowed`;
       message += disallowedAssociations.map((a) => `
-\xB7 Node ${a.nodeId}: ${(0, import_safe2.getEnumMemberName)(import_Types.AssociationCheckResult, a.checkResult).replace("Forbidden_", "")}`).join("");
-      throw new import_safe.ZWaveError(message, import_safe.ZWaveErrorCodes.AssociationCC_NotAllowed, disallowedAssociations);
+\xB7 Node ${a.nodeId}: ${(0, import_shared.getEnumMemberName)(import_Types.AssociationCheckResult, a.checkResult).replace("Forbidden_", "")}`).join("");
+      throw new import_core.ZWaveError(message, import_core.ZWaveErrorCodes.AssociationCC_NotAllowed, disallowedAssociations);
     }
-    const api = import_API.CCAPI.create(import_safe.CommandClasses.Association, ctx, endpoint);
+    const api = import_API.CCAPI.create(import_core.CommandClasses.Association, ctx, endpoint);
     await api.addNodeIds(group, ...destinations.map((a) => a.nodeId));
     await api.getGroup(group);
   }
@@ -276,31 +276,31 @@ async function removeAssociations(ctx, endpoint, group, destinations) {
   let groupExistsAsNodeAssociation = false;
   let mcInstance;
   let assocInstance;
-  if (endpoint.supportsCC(import_safe.CommandClasses["Multi Channel Association"])) {
+  if (endpoint.supportsCC(import_core.CommandClasses["Multi Channel Association"])) {
     mcInstance = import_MultiChannelAssociationCC.MultiChannelAssociationCC;
     if (group <= mcInstance.getGroupCountCached(ctx, endpoint)) {
       groupExistsAsMultiChannel = true;
     }
   } else if (endpointAssociations.length > 0) {
-    throw new import_safe.ZWaveError(`Node ${nodeAndEndpointString} does not support multi channel associations!`, import_safe.ZWaveErrorCodes.CC_NotSupported);
+    throw new import_core.ZWaveError(`Node ${nodeAndEndpointString} does not support multi channel associations!`, import_core.ZWaveErrorCodes.CC_NotSupported);
   }
-  if (endpoint.supportsCC(import_safe.CommandClasses.Association)) {
+  if (endpoint.supportsCC(import_core.CommandClasses.Association)) {
     assocInstance = import_AssociationCC.AssociationCC;
     if (group <= assocInstance.getGroupCountCached(ctx, endpoint)) {
       groupExistsAsNodeAssociation = true;
     }
   }
   if (!mcInstance && !assocInstance) {
-    throw new import_safe.ZWaveError(`Node ${nodeAndEndpointString} does not support associations!`, import_safe.ZWaveErrorCodes.CC_NotSupported);
+    throw new import_core.ZWaveError(`Node ${nodeAndEndpointString} does not support associations!`, import_core.ZWaveErrorCodes.CC_NotSupported);
   }
   if (!groupExistsAsMultiChannel && !groupExistsAsNodeAssociation) {
-    throw new import_safe.ZWaveError(` Association group ${group} does not exist for node ${nodeAndEndpointString}`, import_safe.ZWaveErrorCodes.AssociationCC_InvalidGroup);
+    throw new import_core.ZWaveError(` Association group ${group} does not exist for node ${nodeAndEndpointString}`, import_core.ZWaveErrorCodes.AssociationCC_InvalidGroup);
   }
   if (endpointAssociations.length > 0 && !groupExistsAsMultiChannel) {
-    throw new import_safe.ZWaveError(`Node ${nodeAndEndpointString}, association group ${group} does not support multi channel associations!`, import_safe.ZWaveErrorCodes.AssociationCC_InvalidGroup);
+    throw new import_core.ZWaveError(`Node ${nodeAndEndpointString}, association group ${group} does not support multi channel associations!`, import_core.ZWaveErrorCodes.AssociationCC_InvalidGroup);
   }
   if (assocInstance && nodeAssociations.length > 0 && groupExistsAsNodeAssociation) {
-    const api = import_API.CCAPI.create(import_safe.CommandClasses.Association, ctx, endpoint);
+    const api = import_API.CCAPI.create(import_core.CommandClasses.Association, ctx, endpoint);
     await api.removeNodeIds({
       groupId: group,
       nodeIds: nodeAssociations
@@ -308,7 +308,7 @@ async function removeAssociations(ctx, endpoint, group, destinations) {
     await api.getGroup(group);
   }
   if (mcInstance && groupExistsAsMultiChannel) {
-    const api = import_API.CCAPI.create(import_safe.CommandClasses["Multi Channel Association"], ctx, endpoint);
+    const api = import_API.CCAPI.create(import_core.CommandClasses["Multi Channel Association"], ctx, endpoint);
     await api.removeDestinations({
       groupId: group,
       nodeIds: nodeAssociations,
@@ -322,7 +322,7 @@ function getLifelineGroupIds(ctx, endpoint) {
   if (endpoint.index > 0)
     return [];
   const lifelineGroups = [];
-  if (endpoint.supportsCC(import_safe.CommandClasses["Z-Wave Plus Info"])) {
+  if (endpoint.supportsCC(import_core.CommandClasses["Z-Wave Plus Info"])) {
     lifelineGroups.push(1);
   }
   let associations;
@@ -343,23 +343,23 @@ async function configureLifelineAssociations(ctx, endpoint) {
   const node = ctx.getNodeOrThrow(endpoint.nodeId);
   const valueDB = ctx.getValueDB(node.id);
   const deviceConfig = ctx.getDeviceConfig?.(node.id);
-  const nodeSupportsMultiChannel = node.supportsCC(import_safe.CommandClasses["Multi Channel"]);
+  const nodeSupportsMultiChannel = node.supportsCC(import_core.CommandClasses["Multi Channel"]);
   let assocInstance;
-  const assocAPI = import_API.CCAPI.create(import_safe.CommandClasses.Association, ctx, endpoint);
-  if (endpoint.supportsCC(import_safe.CommandClasses.Association)) {
+  const assocAPI = import_API.CCAPI.create(import_core.CommandClasses.Association, ctx, endpoint);
+  if (endpoint.supportsCC(import_core.CommandClasses.Association)) {
     assocInstance = import_AssociationCC.AssociationCC;
   }
   let mcInstance;
   let mcGroupCount = 0;
-  const mcAPI = import_API.CCAPI.create(import_safe.CommandClasses["Multi Channel Association"], ctx, endpoint);
-  if (endpoint.supportsCC(import_safe.CommandClasses["Multi Channel Association"])) {
+  const mcAPI = import_API.CCAPI.create(import_core.CommandClasses["Multi Channel Association"], ctx, endpoint);
+  if (endpoint.supportsCC(import_core.CommandClasses["Multi Channel Association"])) {
     mcInstance = import_MultiChannelAssociationCC.MultiChannelAssociationCC;
     mcGroupCount = mcInstance.getGroupCountCached(ctx, endpoint) ?? 0;
   }
   const lifelineGroups = getLifelineGroupIds(ctx, node);
   if (lifelineGroups.length === 0) {
-    if (endpoint.supportsCC(import_safe.CommandClasses["Association Group Information"])) {
-      const agiAPI = import_API.CCAPI.create(import_safe.CommandClasses["Association Group Information"], ctx, endpoint);
+    if (endpoint.supportsCC(import_core.CommandClasses["Association Group Information"])) {
+      const agiAPI = import_API.CCAPI.create(import_core.CommandClasses["Association Group Information"], ctx, endpoint);
       const lifeline = await agiAPI.getGroupInfo(1, true).catch(() => void 0);
       if (lifeline?.profile === import_Types.AssociationGroupInfoProfile["General: Lifeline"]) {
         lifelineGroups.push(1);
@@ -391,7 +391,7 @@ supports multi channel associations: ${!!mcInstance}`
         mustUseMultiChannelAssociation = true;
       } else if (endpoint.index === 0) {
         const allEndpoints = node.getAllEndpoints();
-        if (allEndpoints.length > 1 && allEndpoints.filter((e) => e.index !== endpoint.index).every((e) => !e.supportsCC(import_safe.CommandClasses.Association) && !e.supportsCC(import_safe.CommandClasses["Multi Channel Association"]))) {
+        if (allEndpoints.length > 1 && allEndpoints.filter((e) => e.index !== endpoint.index).every((e) => !e.supportsCC(import_core.CommandClasses.Association) && !e.supportsCC(import_core.CommandClasses["Multi Channel Association"]))) {
           mustUseMultiChannelAssociation = true;
         }
       }
@@ -567,7 +567,7 @@ must use endpoint association: ${mustUseMultiChannelAssociation}`
         }
       }
     }
-    if (!hasLifeline && group === 1 && node.supportsCC(import_safe.CommandClasses["Z-Wave Plus Info"]) && endpoint.index > 0) {
+    if (!hasLifeline && group === 1 && node.supportsCC(import_core.CommandClasses["Z-Wave Plus Info"]) && endpoint.index > 0) {
       const rootAssocConfig = deviceConfig?.getAssociationConfigForEndpoint(0, group);
       const rootMustUseNodeAssociation = !nodeSupportsMultiChannel || rootAssocConfig?.multiChannel === false;
       ctx.logNode(node.id, {
@@ -586,8 +586,8 @@ must use node association:     ${rootMustUseNodeAssociation}`
             direction: "none"
           });
         } else {
-          const rootMCAPI = import_API.CCAPI.create(import_safe.CommandClasses["Multi Channel Association"], ctx, node);
-          const rootAssocAPI = import_API.CCAPI.create(import_safe.CommandClasses.Association, ctx, node);
+          const rootMCAPI = import_API.CCAPI.create(import_core.CommandClasses["Multi Channel Association"], ctx, node);
+          const rootAssocAPI = import_API.CCAPI.create(import_core.CommandClasses.Association, ctx, node);
           if (rootMCAPI.isSupported()) {
             ctx.logNode(node.id, {
               endpoint: endpoint.index,
@@ -631,7 +631,7 @@ must use node association:     ${rootMustUseNodeAssociation}`
 __name(configureLifelineAssociations, "configureLifelineAssociations");
 async function assignLifelineIssueingCommand(ctx, endpoint, ccId, ccCommand) {
   const node = ctx.getNodeOrThrow(endpoint.nodeId);
-  if (node.supportsCC(import_safe.CommandClasses["Association Group Information"]) && (node.supportsCC(import_safe.CommandClasses.Association) || node.supportsCC(import_safe.CommandClasses["Multi Channel Association"]))) {
+  if (node.supportsCC(import_core.CommandClasses["Association Group Information"]) && (node.supportsCC(import_core.CommandClasses.Association) || node.supportsCC(import_core.CommandClasses["Multi Channel Association"]))) {
     const groupsIssueingNotifications = import_AssociationGroupInfoCC.AssociationGroupInfoCC.findGroupsForIssuedCommand(ctx, node, ccId, ccCommand);
     if (groupsIssueingNotifications.length > 0) {
       const groupId = groupsIssueingNotifications[0];
@@ -639,7 +639,7 @@ async function assignLifelineIssueingCommand(ctx, endpoint, ccId, ccCommand) {
       if (!existingAssociations.some((a) => a.nodeId === ctx.ownNodeId)) {
         ctx.logNode(node.id, {
           endpoint: endpoint.index,
-          message: `Configuring associations to receive ${(0, import_safe.getCCName)(ccId)} commands...`,
+          message: `Configuring associations to receive ${(0, import_core.getCCName)(ccId)} commands...`,
           direction: "outbound"
         });
         await addAssociations(ctx, node, groupId, [
@@ -651,11 +651,11 @@ async function assignLifelineIssueingCommand(ctx, endpoint, ccId, ccCommand) {
 }
 __name(assignLifelineIssueingCommand, "assignLifelineIssueingCommand");
 function doesAnyLifelineSendActuatorOrSensorReports(ctx, node) {
-  if (!node.supportsCC(import_safe.CommandClasses.Association) && !node.supportsCC(import_safe.CommandClasses["Multi Channel Association"])) {
+  if (!node.supportsCC(import_core.CommandClasses.Association) && !node.supportsCC(import_core.CommandClasses["Multi Channel Association"])) {
     return false;
   }
-  if (!node.supportsCC(import_safe.CommandClasses["Association Group Information"])) {
-    return import_safe.NOT_KNOWN;
+  if (!node.supportsCC(import_core.CommandClasses["Association Group Information"])) {
+    return import_core.NOT_KNOWN;
   }
   const lifelineGroupIds = getLifelineGroupIds(ctx, node);
   if (lifelineGroupIds.some((id) => import_AssociationGroupInfoCC.AssociationGroupInfoCC.getGroupProfileCached(ctx, node, id) === import_Types.AssociationGroupInfoProfile["General: Lifeline"])) {
@@ -666,7 +666,7 @@ function doesAnyLifelineSendActuatorOrSensorReports(ctx, node) {
     if (!issuedCommands)
       continue;
     const commands = [...issuedCommands.keys()];
-    if (commands.some((c) => (0, import_safe.isActuatorCC)(c) || (0, import_safe.isSensorCC)(c))) {
+    if (commands.some((c) => (0, import_core.isActuatorCC)(c) || (0, import_core.isSensorCC)(c))) {
       return true;
     }
   }