@matter/protocol 0.16.0-alpha.0-20251213-e83db3732 → 0.16.0-alpha.0-20251217-038f88085

package/dist/cjs/peer/ControllerCommissioningFlow.js

@@ -18,8 +18,6 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var ControllerCommissioningFlow_exports = {};
 __export(ControllerCommissioningFlow_exports, {
-  CommissionableDeviceDiscoveryFailedError: () => CommissionableDeviceDiscoveryFailedError,
-  CommissioningError: () => CommissioningError,
   CommissioningTimeoutError: () => CommissioningTimeoutError,
   ControllerCommissioningFlow: () => ControllerCommissioningFlow,
   DeviceAlreadyCommissionedToThisFabricError: () => DeviceAlreadyCommissionedToThisFabricError,
@@ -32,6 +30,8 @@ __export(ControllerCommissioningFlow_exports, {
   WifiOrThreadNetworkCredentialsNotConfiguredError: () => WifiOrThreadNetworkCredentialsNotConfiguredError
 });
 module.exports = __toCommonJS(ControllerCommissioningFlow_exports);
+var import_Invoke = require("#action/request/Invoke.js");
+var import_Read = require("#action/request/Read.js");
 var import_Certificate = require("#certificate/kinds/Certificate.js");
 var import_basic_information = require("#clusters/basic-information");
 var import_descriptor = require("#clusters/descriptor");
@@ -41,8 +41,8 @@ var import_operational_credentials = require("#clusters/operational-credentials"
 var import_time_synchronization = require("#clusters/time-synchronization");
 var import_general = require("#general");
 var import_types = require("#types");
-var import_ClusterClient = require("../cluster/client/ClusterClient.js");
 var import_OperationalCredentialsTypes = require("../common/OperationalCredentialsTypes.js");
+var import_CommissioningError = require("./CommissioningError.js");
 /**
  * @license
  * Copyright 2022-2025 Matter.js Authors
@@ -56,33 +56,30 @@ var CommissioningStepResultCode = /* @__PURE__ */ ((CommissioningStepResultCode2
   CommissioningStepResultCode2[CommissioningStepResultCode2["Stop"] = 3] = "Stop";
   return CommissioningStepResultCode2;
 })(CommissioningStepResultCode || {});
-class CommissioningError extends import_general.MatterError {
+class MaximumCommissionedFabricsReachedError extends import_CommissioningError.CommissioningError {
 }
-class MaximumCommissionedFabricsReachedError extends CommissioningError {
+class CommissioningTimeoutError extends import_CommissioningError.CommissioningError {
 }
-class CommissioningTimeoutError extends CommissioningError {
+class DeviceAlreadyCommissionedToThisFabricError extends import_CommissioningError.CommissioningError {
 }
-class DeviceAlreadyCommissionedToThisFabricError extends CommissioningError {
+class FabricLabelConflictError extends import_CommissioningError.CommissioningError {
 }
-class FabricLabelConflictError extends CommissioningError {
+class WifiOrThreadNetworkCredentialsNotConfiguredError extends import_CommissioningError.CommissioningError {
 }
-class WifiOrThreadNetworkCredentialsNotConfiguredError extends CommissioningError {
+class WifiNetworkSetupFailedError extends import_CommissioningError.CommissioningError {
 }
-class WifiNetworkSetupFailedError extends CommissioningError {
+class ThreadNetworkSetupFailedError extends import_CommissioningError.CommissioningError {
 }
-class ThreadNetworkSetupFailedError extends CommissioningError {
+class NodeIdConflictError extends import_CommissioningError.CommissioningError {
 }
-class NodeIdConflictError extends CommissioningError {
+class OperativeConnectionFailedError extends import_CommissioningError.CommissioningError {
 }
-class CommissionableDeviceDiscoveryFailedError extends CommissioningError {
-}
-class OperativeConnectionFailedError extends CommissioningError {
-}
-class RecoverableCommissioningError extends CommissioningError {
+class RecoverableCommissioningError extends import_CommissioningError.CommissioningError {
 }
 const DEFAULT_FAILSAFE_TIME = import_general.Minutes.one;
+const RootEndpointNumber = (0, import_types.EndpointNumber)(0);
 class ControllerCommissioningFlow {
-  interactionClient;
+  interaction;
   ca;
   fabric;
   transitionToCase;
@@ -96,8 +93,8 @@ class ControllerCommissioningFlow {
   lastBreadcrumb = 1;
   collectedCommissioningData = {};
   #defaultFailSafeTime = DEFAULT_FAILSAFE_TIME;
-  constructor(interactionClient, ca, fabric, commissioningOptions, transitionToCase) {
-    this.interactionClient = interactionClient;
+  constructor(interaction, ca, fabric, commissioningOptions, transitionToCase) {
+    this.interaction = interaction;
     this.ca = ca;
     this.fabric = fabric;
     this.transitionToCase = transitionToCase;
@@ -151,13 +148,13 @@ class ControllerCommissioningFlow {
           logger.warn(
             `Commissioning step ${step.stepNumber}.${step.subStepNumber}: ${step.name} failed with recoverable error: ${error.message} ... Continuing with process`
           );
-        } else if (error instanceof CommissioningError || error instanceof import_types.StatusResponseError) {
+        } else if (error instanceof import_CommissioningError.CommissioningError || error instanceof import_types.StatusResponseError) {
           logger.error(
             `Commissioning step ${step.stepNumber}.${step.subStepNumber}: ${step.name} failed with error: ${error.message} ... Aborting commissioning`
           );
           await this.#resetFailsafeTimer();
           import_types.StatusResponseError.accept(error);
-          throw (0, import_general.repackErrorAs)(error, CommissioningError);
+          throw (0, import_general.repackErrorAs)(error, import_CommissioningError.CommissioningError);
         } else {
           throw error;
         }
@@ -165,24 +162,58 @@ class ControllerCommissioningFlow {
     }
   }
   /**
-   * Helper method to create ClusterClients. If not feature specific and for the Root Endpoint they are also reused.
+   * Convenience method to get a number of attributes in a read and return exactly these values in the order as
+   * defined in the request
    */
-  #getClusterClient(cluster, endpointId = (0, import_types.EndpointNumber)(0), isFeatureSpecific = false) {
-    if (!isFeatureSpecific && endpointId === 0) {
-      const clusterClient = this.#clusterClients.get(cluster.id);
-      if (clusterClient !== void 0) {
-        logger.debug(
-          `Returning existing cluster client for cluster ${cluster.name} (endpoint ${endpointId}, isFeatureSpecific ${isFeatureSpecific})`
-        );
-        return clusterClient;
+  async #readConcreteAttributeValues(request) {
+    const attributeMap = /* @__PURE__ */ new Map();
+    if (request.attributeRequests === void 0) {
+      throw new import_general.ImplementationError("Can only handle Attribute reads");
+    }
+    for (const { endpointId, clusterId, attributeId } of request.attributeRequests) {
+      if (endpointId === void 0 || clusterId === void 0) {
+        continue;
+      }
+      attributeMap.set(`${endpointId}-${clusterId}-${attributeId}`, void 0);
+    }
+    for await (const data of this.interaction.read(request)) {
+      for (const entry of data) {
+        if (entry.kind !== "attr-value") {
+          continue;
+        }
+        const {
+          path: { endpointId, clusterId, attributeId },
+          value
+        } = entry;
+        const key = `${endpointId}-${clusterId}-${attributeId}`;
+        if (!attributeMap.has(key)) {
+          continue;
+        }
+        attributeMap.set(key, value);
+      }
+    }
+    return [...attributeMap.values()];
+  }
+  // TODO improve response typing
+  async #invokeCommand(request, options = {}) {
+    for await (const data of this.interaction.invoke(
+      (0, import_Invoke.Invoke)({
+        commands: [request],
+        ...options
+      })
+    )) {
+      for (const entry of data) {
+        switch (entry.kind) {
+          case "cmd-status":
+            if (entry.status !== import_types.Status.Success) {
+              throw import_types.StatusResponseError.create(entry.status, void 0, entry.clusterStatus);
+            }
+            return;
+          case "cmd-response":
+            return entry.data;
+        }
       }
     }
-    logger.debug(
-      `Creating new cluster client for cluster ${cluster.name} (endpoint ${endpointId}, isFeatureSpecific ${isFeatureSpecific})`
-    );
-    const client = (0, import_ClusterClient.ClusterClient)(cluster, endpointId, this.interactionClient);
-    this.#clusterClients.set(cluster.id, client);
-    return client;
   }
   /**
    * Initialize commissioning steps and add them in the default order as defined by
@@ -233,7 +264,7 @@ class ControllerCommissioningFlow {
       name: "AccessControl",
       stepLogic: () => this.#configureAccessControlLists()
     });
-    if (this.interactionClient.channelType === import_general.ChannelType.BLE) {
+    if (this.interaction.channelType === import_general.ChannelType.BLE) {
       this.commissioningSteps.push({
         stepNumber: 16,
         subStepNumber: 1,
@@ -262,7 +293,7 @@ class ControllerCommissioningFlow {
       }
     } else {
       logger.info(
-        `Skipping NetworkCommissioning steps because the device is already on IP network (${this.interactionClient.channelType})`
+        `Skipping NetworkCommissioning steps because the device is already on IP network (${this.interaction.channelType})`
       );
     }
     this.commissioningSteps.push({
@@ -320,7 +351,7 @@ class ControllerCommissioningFlow {
         );
       }
     }
-    throw new CommissioningError(
+    throw new import_CommissioningError.CommissioningError(
       `Commission error for "${context}": ${import_operational_credentials.OperationalCredentials.NodeOperationalCertStatus[statusCode]} (${statusCode}), ${debugText}${fabricIndex !== void 0 ? `, fabricIndex: ${fabricIndex}` : ""}`
     );
   }
@@ -328,7 +359,7 @@ class ControllerCommissioningFlow {
   #ensureGeneralCommissioningSuccess(context, { errorCode, debugText }) {
     logger.debug(`Commissioning step ${context} returned ${errorCode}, ${debugText}`);
     if (errorCode === import_general_commissioning.GeneralCommissioning.CommissioningError.Ok) return;
-    throw new CommissioningError(
+    throw new import_CommissioningError.CommissioningError(
       `Commission error for "${context}": ${import_general_commissioning.GeneralCommissioning.CommissioningError[errorCode]} (${errorCode})${debugText ? `, ${debugText}` : ""}`
     );
   }
@@ -336,49 +367,84 @@ class ControllerCommissioningFlow {
    * Initial Step to receive some common data used by other steps
    */
   async #getInitialData() {
-    const operationalCredentialsClient = this.#getClusterClient(import_operational_credentials.OperationalCredentials.Cluster);
-    const supportedFabrics = await operationalCredentialsClient.getSupportedFabricsAttribute();
-    const commissionedFabrics = await operationalCredentialsClient.getCommissionedFabricsAttribute();
+    const [
+      supportedFabrics,
+      commissionedFabrics,
+      rootPartsList,
+      rootServerList,
+      vendorId,
+      productId,
+      productName,
+      supportsConcurrentConnection
+    ] = await this.#readConcreteAttributeValues(
+      (0, import_Read.Read)(
+        import_Read.Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: import_operational_credentials.OperationalCredentials.Complete,
+          attributes: ["supportedFabrics", "commissionedFabrics"]
+        }),
+        import_Read.Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: import_descriptor.Descriptor.Complete,
+          attributes: ["partsList", "serverList"]
+        }),
+        import_Read.Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: import_basic_information.BasicInformation.Complete,
+          attributes: ["vendorId", "productId", "productName"]
+        }),
+        import_Read.Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: import_general_commissioning.GeneralCommissioning.Complete,
+          attributes: ["supportsConcurrentConnection"]
+        })
+      )
+    );
     if (commissionedFabrics >= supportedFabrics) {
       throw new MaximumCommissionedFabricsReachedError(
         `Commissioned fabrics (${commissionedFabrics}) exceed supported fabrics (${supportedFabrics}). Please remove some fabrics before commissioning.`
       );
     }
-    const descriptorClient = this.#getClusterClient(import_descriptor.Descriptor.Cluster);
-    this.collectedCommissioningData.rootPartsList = await descriptorClient.getPartsListAttribute();
-    this.collectedCommissioningData.rootServerList = await descriptorClient.getServerListAttribute();
-    const networkData = await this.interactionClient.getMultipleAttributes({
-      attributes: [
-        {
-          clusterId: import_network_commissioning.NetworkCommissioning.Complete.id,
-          attributeId: import_network_commissioning.NetworkCommissioning.Complete.attributes.featureMap.id
-        },
-        {
-          clusterId: import_network_commissioning.NetworkCommissioning.Complete.id,
-          attributeId: import_network_commissioning.NetworkCommissioning.Complete.attributes.networks.id
-        }
-      ]
-    });
+    this.collectedCommissioningData.rootPartsList = rootPartsList;
+    this.collectedCommissioningData.rootServerList = rootServerList;
+    this.collectedCommissioningData.vendorId = vendorId;
+    this.collectedCommissioningData.productId = productId;
+    this.collectedCommissioningData.productName = productName;
+    this.collectedCommissioningData.supportsConcurrentConnection = supportsConcurrentConnection;
+    const networkData = this.interaction.read(
+      (0, import_Read.Read)(
+        import_Read.Read.Attribute({
+          cluster: import_network_commissioning.NetworkCommissioning.Complete,
+          attributes: ["featureMap", "networks"]
+        })
+      )
+    );
     const networkFeatures = new Array();
     const networkStatus = new Array();
-    for (const {
-      path: { endpointId, attributeId },
-      value
-    } of networkData) {
-      if (attributeId === import_network_commissioning.NetworkCommissioning.Complete.attributes.featureMap.id) {
-        networkFeatures.push({ endpointId, value });
-      } else if (attributeId === import_network_commissioning.NetworkCommissioning.Complete.attributes.networks.id) {
-        networkStatus.push({ endpointId, value });
+    for await (const data of networkData) {
+      for (const entry of data) {
+        if (entry.kind !== "attr-value") {
+          continue;
+        }
+        const {
+          path: { endpointId, attributeId },
+          value
+        } = entry;
+        if (attributeId === import_network_commissioning.NetworkCommissioning.Complete.attributes.featureMap.id) {
+          networkFeatures.push({
+            endpointId,
+            value
+          });
+        } else if (attributeId === import_network_commissioning.NetworkCommissioning.Complete.attributes.networks.id) {
+          networkStatus.push({
+            endpointId,
+            value
+          });
+        }
       }
     }
     this.collectedCommissioningData.networkFeatures = networkFeatures;
     this.collectedCommissioningData.networkStatus = networkStatus;
-    const basicInfoClient = this.#getClusterClient(import_basic_information.BasicInformation.Cluster);
-    this.collectedCommissioningData.vendorId = await basicInfoClient.getVendorIdAttribute();
-    this.collectedCommissioningData.productId = await basicInfoClient.getProductIdAttribute();
-    this.collectedCommissioningData.productName = await basicInfoClient.getProductNameAttribute();
-    const generalCommissioningClient = this.#getClusterClient(import_general_commissioning.GeneralCommissioning.Cluster);
-    this.collectedCommissioningData.supportsConcurrentConnection = await generalCommissioningClient.getSupportsConcurrentConnectionAttribute();
     return {
       code: 0 /* Success */,
       breadcrumb: this.lastBreadcrumb
@@ -394,9 +460,16 @@ class ControllerCommissioningFlow {
    * Attribute”) prior to invoking the ArmFailSafe command.
    */
   async #armFailsafe(time) {
-    const client = this.#getClusterClient(import_general_commissioning.GeneralCommissioning.Cluster);
     if (this.collectedCommissioningData.basicCommissioningInfo === void 0) {
-      const basicCommissioningInfo = await client.getBasicCommissioningInfoAttribute();
+      const [basicCommissioningInfo] = await this.#readConcreteAttributeValues(
+        (0, import_Read.Read)(
+          import_Read.Read.Attribute({
+            endpoint: RootEndpointNumber,
+            cluster: import_general_commissioning.GeneralCommissioning.Complete,
+            attributes: ["basicCommissioningInfo"]
+          })
+        )
+      );
       this.collectedCommissioningData.basicCommissioningInfo = basicCommissioningInfo;
       this.#defaultFailSafeTime = (0, import_general.Seconds)(basicCommissioningInfo.failSafeExpiryLengthSeconds);
       this.#commissioningStartedTime = import_general.Time.nowMs;
@@ -407,9 +480,14 @@ class ControllerCommissioningFlow {
     const expiryLength = time ?? this.#defaultFailSafeTime;
     this.#ensureGeneralCommissioningSuccess(
       "armFailSafe",
-      await client.armFailSafe({
-        breadcrumb: this.lastBreadcrumb,
-        expiryLengthSeconds: import_general.Seconds.of(expiryLength)
+      await this.#invokeCommand({
+        endpoint: RootEndpointNumber,
+        cluster: import_general_commissioning.GeneralCommissioning.Complete,
+        command: "armFailSafe",
+        fields: {
+          breadcrumb: this.lastBreadcrumb,
+          expiryLengthSeconds: import_general.Seconds.of(expiryLength)
+        }
       })
     );
     this.#currentFailSafeEndTime = (0, import_general.Timestamp)(import_general.Time.nowMs + expiryLength);
@@ -425,22 +503,26 @@ class ControllerCommissioningFlow {
     return import_general.Duration.max((0, import_general.Timespan)(import_general.Time.nowMs, this.#currentFailSafeEndTime).duration, 0);
   }
   async #ensureFailsafeTimerFor(maxProcessingTime) {
-    const minFailsafeTime = this.interactionClient.maximumPeerResponseTime(maxProcessingTime);
+    const minFailsafeTime = this.interaction.maximumPeerResponseTime(maxProcessingTime);
     const timeLeft = this.#failSafeTimeLeft;
     if (timeLeft < minFailsafeTime) {
       logger.debug(`Failsafe timer has only ${timeLeft}s left, re-arming for at least ${minFailsafeTime}`);
       await this.#armFailsafe(import_general.Duration.max(minFailsafeTime, this.#defaultFailSafeTime));
     } else {
-      logger.debug(`Failsafe timer is already set for at least ${timeLeft}s`);
+      logger.debug(`Failsafe timer is already set for at least ${import_general.Seconds.of(timeLeft)}s`);
     }
   }
   async #resetFailsafeTimer() {
     if (this.#currentFailSafeEndTime === void 0) return;
     try {
-      const client = this.#getClusterClient(import_general_commissioning.GeneralCommissioning.Cluster);
-      await client.armFailSafe({
-        breadcrumb: this.lastBreadcrumb,
-        expiryLengthSeconds: 0
+      await this.#invokeCommand({
+        endpoint: RootEndpointNumber,
+        cluster: import_general_commissioning.GeneralCommissioning.Complete,
+        command: "armFailSafe",
+        fields: {
+          breadcrumb: this.lastBreadcrumb,
+          expiryLengthSeconds: 0
+        }
       });
       this.#currentFailSafeEndTime = void 0;
     } catch (error) {
@@ -456,7 +538,7 @@ class ControllerCommissioningFlow {
    */
   async #configureRegulatoryInformation() {
     if (this.collectedCommissioningData.networkFeatures === void 0) {
-      throw new CommissioningError(
+      throw new import_CommissioningError.CommissioningError(
         "Initial information collection failed. No network features collected. This should never happen."
       );
     }
@@ -464,8 +546,15 @@ class ControllerCommissioningFlow {
       ({ value: { wiFiNetworkInterface, threadNetworkInterface } }) => wiFiNetworkInterface || threadNetworkInterface
     );
     if (hasRadioNetwork) {
-      const client = this.#getClusterClient(import_general_commissioning.GeneralCommissioning.Cluster);
-      let locationCapability = await client.getLocationCapabilityAttribute();
+      let [locationCapability] = await this.#readConcreteAttributeValues(
+        (0, import_Read.Read)(
+          import_Read.Read.Attribute({
+            endpoint: RootEndpointNumber,
+            cluster: import_general_commissioning.GeneralCommissioning.Complete,
+            attributes: ["locationCapability"]
+          })
+        )
+      );
       if (locationCapability === import_general_commissioning.GeneralCommissioning.RegulatoryLocationType.IndoorOutdoor) {
         locationCapability = this.commissioningOptions.regulatoryLocation;
       } else {
@@ -474,13 +563,20 @@ class ControllerCommissioningFlow {
         );
       }
       let countryCode = this.commissioningOptions.regulatoryCountryCode;
-      const regulatoryResult = await client.setRegulatoryConfig(
+      const regulatoryResult = await this.#invokeCommand(
         {
-          breadcrumb: this.lastBreadcrumb++,
-          newRegulatoryConfig: locationCapability,
-          countryCode
+          endpoint: RootEndpointNumber,
+          cluster: import_general_commissioning.GeneralCommissioning.Complete,
+          command: "setRegulatoryConfig",
+          fields: {
+            breadcrumb: this.lastBreadcrumb++,
+            newRegulatoryConfig: locationCapability,
+            countryCode
+          }
         },
-        { useExtendedFailSafeMessageResponseTimeout: true }
+        {
+          useExtendedFailSafeMessageResponseTimeout: true
+        }
       );
       if (regulatoryResult.errorCode === import_general_commissioning.GeneralCommissioning.CommissioningError.ValueOutsideRange && countryCode !== "XX") {
         logger.debug(
@@ -489,13 +585,20 @@ class ControllerCommissioningFlow {
         countryCode = "XX";
         this.#ensureGeneralCommissioningSuccess(
           "setRegulatoryConfig",
-          await client.setRegulatoryConfig(
+          await this.#invokeCommand(
             {
-              breadcrumb: this.lastBreadcrumb,
-              newRegulatoryConfig: locationCapability,
-              countryCode
+              endpoint: RootEndpointNumber,
+              cluster: import_general_commissioning.GeneralCommissioning.Complete,
+              command: "setRegulatoryConfig",
+              fields: {
+                breadcrumb: this.lastBreadcrumb,
+                newRegulatoryConfig: locationCapability,
+                countryCode
+              }
             },
-            { useExtendedFailSafeMessageResponseTimeout: true }
+            {
+              useExtendedFailSafeMessageResponseTimeout: true
+            }
           )
         );
       } else {
@@ -537,27 +640,47 @@ class ControllerCommissioningFlow {
    * (see Section 6.2.3, “Device Attestation Procedure”).
    */
   async #deviceAttestation() {
-    const operationalCredentialsClusterClient = this.#getClusterClient(import_operational_credentials.OperationalCredentials.Cluster);
-    const { certificate: deviceAttestation } = await operationalCredentialsClusterClient.certificateChainRequest(
+    const { certificate: deviceAttestation } = await this.#invokeCommand(
       {
-        certificateType: import_operational_credentials.OperationalCredentials.CertificateChainType.DacCertificate
+        endpoint: RootEndpointNumber,
+        cluster: import_operational_credentials.OperationalCredentials.Complete,
+        command: "certificateChainRequest",
+        fields: {
+          certificateType: import_operational_credentials.OperationalCredentials.CertificateChainType.DacCertificate
+        }
       },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
-    const { certificate: productAttestation } = await operationalCredentialsClusterClient.certificateChainRequest(
+    const { certificate: productAttestation } = await this.#invokeCommand(
       {
-        certificateType: import_operational_credentials.OperationalCredentials.CertificateChainType.PaiCertificate
+        endpoint: RootEndpointNumber,
+        cluster: import_operational_credentials.OperationalCredentials.Complete,
+        command: "certificateChainRequest",
+        fields: {
+          certificateType: import_operational_credentials.OperationalCredentials.CertificateChainType.PaiCertificate
+        }
       },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
-    const { attestationElements, attestationSignature } = await operationalCredentialsClusterClient.attestationRequest(
+    const { attestationElements, attestationSignature } = await this.#invokeCommand(
       {
-        attestationNonce: this.fabric.crypto.randomBytes(32)
+        endpoint: RootEndpointNumber,
+        cluster: import_operational_credentials.OperationalCredentials.Complete,
+        command: "attestationRequest",
+        fields: {
+          attestationNonce: this.fabric.crypto.randomBytes(32)
+        }
       },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
     if (deviceAttestation.byteLength === 0 || productAttestation.byteLength === 0 || attestationElements.byteLength === 0 || attestationSignature.byteLength === 0) {
-      throw new CommissioningError("Device Attestation data missing from device");
+      throw new import_CommissioningError.CommissioningError("Device Attestation data missing from device");
     }
     return {
       code: 0 /* Success */,
@@ -581,36 +704,56 @@ class ControllerCommissioningFlow {
    *     DCL contains the name and other information of the Commissioner’s manufacturer.
    */
   async #certificates() {
-    const operationalCredentialsClusterClient = this.#getClusterClient(import_operational_credentials.OperationalCredentials.Cluster);
-    const { nocsrElements, attestationSignature: csrSignature } = await operationalCredentialsClusterClient.csrRequest(
-      { csrNonce: this.fabric.crypto.randomBytes(32) },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+    const { nocsrElements, attestationSignature: csrSignature } = await this.#invokeCommand(
+      {
+        endpoint: RootEndpointNumber,
+        cluster: import_operational_credentials.OperationalCredentials.Complete,
+        command: "csrRequest",
+        fields: { csrNonce: this.fabric.crypto.randomBytes(32) }
+      },
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
     if (nocsrElements.byteLength === 0 || csrSignature.byteLength === 0) {
       throw new import_general.UnexpectedDataError("Invalid response from device");
     }
     const { certSigningRequest } = import_OperationalCredentialsTypes.TlvCertSigningRequest.decode(nocsrElements);
     const operationalPublicKey = await import_Certificate.Certificate.getPublicKeyFromCsr(this.ca.crypto, certSigningRequest);
-    await operationalCredentialsClusterClient.addTrustedRootCertificate(
+    await this.#invokeCommand(
       {
-        rootCaCertificate: this.ca.rootCert
+        endpoint: RootEndpointNumber,
+        cluster: import_operational_credentials.OperationalCredentials.Complete,
+        command: "addTrustedRootCertificate",
+        fields: {
+          rootCaCertificate: this.ca.rootCert
+        }
       },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
     const peerOperationalCert = await this.ca.generateNoc(
       operationalPublicKey,
       this.fabric.fabricId,
-      this.interactionClient.address.nodeId
+      this.interaction.address.nodeId
     );
-    const addNocResponse = await operationalCredentialsClusterClient.addNoc(
+    const addNocResponse = await this.#invokeCommand(
       {
-        nocValue: peerOperationalCert,
-        icacValue: this.ca.icacCert ?? new Uint8Array(0),
-        ipkValue: this.fabric.identityProtectionKey,
-        adminVendorId: this.fabric.rootVendorId,
-        caseAdminSubject: this.fabric.rootNodeId
+        endpoint: RootEndpointNumber,
+        cluster: import_operational_credentials.OperationalCredentials.Complete,
+        command: "addNoc",
+        fields: {
+          nocValue: peerOperationalCert,
+          icacValue: this.ca.icacCert ?? new Uint8Array(0),
+          ipkValue: this.fabric.identityProtectionKey,
+          adminVendorId: this.fabric.rootVendorId,
+          caseAdminSubject: this.fabric.rootNodeId
+        }
       },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
     this.#ensureOperationalCredentialsSuccess("addNoc", addNocResponse);
     const { fabricIndex } = addNocResponse;
@@ -636,13 +779,17 @@ class ControllerCommissioningFlow {
         breadcrumb: this.lastBreadcrumb
       };
     }
-    const operationalCredentialCluster = this.#getClusterClient(import_operational_credentials.OperationalCredentials.Cluster);
     try {
       this.#ensureOperationalCredentialsSuccess(
         "updateFabricLabel",
-        await operationalCredentialCluster.updateFabricLabel({
-          label: this.fabric.label,
-          fabricIndex
+        await this.#invokeCommand({
+          endpoint: RootEndpointNumber,
+          cluster: import_operational_credentials.OperationalCredentials.Complete,
+          command: "updateFabricLabel",
+          fields: {
+            label: this.fabric.label,
+            fabricIndex
+          }
         })
       );
     } catch (error) {
@@ -681,7 +828,7 @@ class ControllerCommissioningFlow {
    */
   async #validateNetwork() {
     if (this.collectedCommissioningData.networkFeatures === void 0 || this.collectedCommissioningData.networkStatus === void 0) {
-      throw new CommissioningError(
+      throw new import_CommissioningError.CommissioningError(
         "Initial information collection failed. No network features or status collected. This should never happen."
       );
     }
@@ -738,22 +885,32 @@ class ControllerCommissioningFlow {
       }
     }
     logger.debug("Configuring WiFi network ...");
-    const networkCommissioningClusterClient = this.#getClusterClient(
-      import_network_commissioning.NetworkCommissioning.Cluster.with("WiFiNetworkInterface"),
-      (0, import_types.EndpointNumber)(0),
-      true
-    );
     const ssid = import_general.Bytes.fromString(this.commissioningOptions.wifiNetwork.wifiSsid);
     const credentials = import_general.Bytes.fromString(this.commissioningOptions.wifiNetwork.wifiCredentials);
+    const [scanMaxTimeSeconds, connectMaxTimeSeconds] = await this.#readConcreteAttributeValues(
+      (0, import_Read.Read)(
+        import_Read.Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: import_network_commissioning.NetworkCommissioning.Complete,
+          attributes: ["scanMaxTimeSeconds", "connectMaxTimeSeconds"]
+        })
+      )
+    );
     if (this.collectedCommissioningData.supportsConcurrentConnection !== false) {
-      const scanMaxTime = (0, import_general.Seconds)(await networkCommissioningClusterClient.getScanMaxTimeSecondsAttribute());
-      await this.#ensureFailsafeTimerFor(scanMaxTime);
-      const { networkingStatus, wiFiScanResults, debugText } = await networkCommissioningClusterClient.scanNetworks(
+      await this.#ensureFailsafeTimerFor((0, import_general.Seconds)(scanMaxTimeSeconds));
+      const { networkingStatus, wiFiScanResults, debugText } = await this.#invokeCommand(
         {
-          ssid,
-          breadcrumb: this.lastBreadcrumb++
+          endpoint: RootEndpointNumber,
+          cluster: import_network_commissioning.NetworkCommissioning.Complete,
+          command: "scanNetworks",
+          fields: {
+            ssid,
+            breadcrumb: this.lastBreadcrumb++
+          }
         },
-        { expectedProcessingTime: scanMaxTime }
+        {
+          expectedProcessingTime: (0, import_general.Seconds)(scanMaxTimeSeconds)
+        }
       );
       if (networkingStatus !== import_network_commissioning.NetworkCommissioning.NetworkCommissioningStatus.Success) {
         throw new WifiNetworkSetupFailedError(`Commissionee failed to scan for WiFi networks: ${debugText}`);
@@ -768,13 +925,20 @@ class ControllerCommissioningFlow {
       networkingStatus: addNetworkingStatus,
       debugText: addDebugText,
       networkIndex
-    } = await networkCommissioningClusterClient.addOrUpdateWiFiNetwork(
+    } = await this.#invokeCommand(
       {
-        ssid,
-        credentials,
-        breadcrumb: this.lastBreadcrumb++
+        endpoint: RootEndpointNumber,
+        cluster: import_network_commissioning.NetworkCommissioning.Complete,
+        command: "addOrUpdateWiFiNetwork",
+        fields: {
+          ssid,
+          credentials,
+          breadcrumb: this.lastBreadcrumb++
+        }
       },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
     if (addNetworkingStatus !== import_network_commissioning.NetworkCommissioning.NetworkCommissioningStatus.Success) {
       throw new WifiNetworkSetupFailedError(`Commissionee failed to add WiFi network: ${addDebugText}`);
@@ -785,7 +949,15 @@ class ControllerCommissioningFlow {
     logger.debug(
       `Commissionee added WiFi network ${this.commissioningOptions.wifiNetwork.wifiSsid} with network index ${networkIndex}`
     );
-    const updatedNetworks = await networkCommissioningClusterClient.getNetworksAttribute();
+    const [updatedNetworks] = await this.#readConcreteAttributeValues(
+      (0, import_Read.Read)(
+        import_Read.Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: import_network_commissioning.NetworkCommissioning.Complete,
+          attributes: ["networks"]
+        })
+      )
+    );
     if (updatedNetworks[networkIndex] === void 0) {
       throw new WifiNetworkSetupFailedError(`Commissionee did not return network with index ${networkIndex}`);
     }
@@ -800,14 +972,20 @@ class ControllerCommissioningFlow {
         breadcrumb: this.lastBreadcrumb
       };
     }
-    const connectMaxTime = (0, import_general.Seconds)(await networkCommissioningClusterClient.getConnectMaxTimeSecondsAttribute());
-    await this.#ensureFailsafeTimerFor(connectMaxTime);
-    const connectResult = await networkCommissioningClusterClient.connectNetwork(
+    await this.#ensureFailsafeTimerFor((0, import_general.Seconds)(connectMaxTimeSeconds));
+    const connectResult = await this.#invokeCommand(
       {
-        networkId,
-        breadcrumb: this.lastBreadcrumb++
+        endpoint: RootEndpointNumber,
+        cluster: import_network_commissioning.NetworkCommissioning.Complete,
+        command: "connectNetwork",
+        fields: {
+          networkId,
+          breadcrumb: this.lastBreadcrumb++
+        }
       },
-      { expectedProcessingTime: connectMaxTime }
+      {
+        expectedProcessingTime: (0, import_general.Seconds)(connectMaxTimeSeconds)
+      }
     );
     if (connectResult.networkingStatus !== import_network_commissioning.NetworkCommissioning.NetworkCommissioningStatus.Success) {
       throw new WifiNetworkSetupFailedError(
@@ -864,17 +1042,29 @@ class ControllerCommissioningFlow {
       }
     }
     logger.debug("Configuring Thread network ...");
-    const networkCommissioningClusterClient = this.#getClusterClient(
-      import_network_commissioning.NetworkCommissioning.Cluster.with("ThreadNetworkInterface"),
-      (0, import_types.EndpointNumber)(0),
-      true
+    const [scanMaxTimeSeconds, connectMaxTimeSeconds] = await this.#readConcreteAttributeValues(
+      (0, import_Read.Read)(
+        import_Read.Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: import_network_commissioning.NetworkCommissioning.Complete,
+          attributes: ["scanMaxTimeSeconds", "connectMaxTimeSeconds"]
+        })
+      )
     );
-    if (this.collectedCommissioningData.supportsConcurrentConnection !== false) {
-      const scanMaxTime = (0, import_general.Seconds)(await networkCommissioningClusterClient.getScanMaxTimeSecondsAttribute());
-      await this.#ensureFailsafeTimerFor(scanMaxTime);
-      const { networkingStatus, threadScanResults, debugText } = await networkCommissioningClusterClient.scanNetworks(
-        { breadcrumb: this.lastBreadcrumb++ },
-        { expectedProcessingTime: scanMaxTime }
+    if (!this.commissioningOptions.threadNetwork?.networkName) {
+      logger.info("Thread network name is not configured. Skip scanning for it.");
+    } else if (this.collectedCommissioningData.supportsConcurrentConnection !== false) {
+      await this.#ensureFailsafeTimerFor((0, import_general.Seconds)(scanMaxTimeSeconds));
+      const { networkingStatus, threadScanResults, debugText } = await this.#invokeCommand(
+        {
+          endpoint: RootEndpointNumber,
+          cluster: import_network_commissioning.NetworkCommissioning.Complete,
+          command: "scanNetworks",
+          fields: { breadcrumb: this.lastBreadcrumb++ }
+        },
+        {
+          expectedProcessingTime: (0, import_general.Seconds)(scanMaxTimeSeconds)
+        }
       );
       if (networkingStatus !== import_network_commissioning.NetworkCommissioning.NetworkCommissioningStatus.Success) {
         throw new ThreadNetworkSetupFailedError(
@@ -902,12 +1092,19 @@ class ControllerCommissioningFlow {
       networkingStatus: addNetworkingStatus,
       debugText: addDebugText,
       networkIndex
-    } = await networkCommissioningClusterClient.addOrUpdateThreadNetwork(
+    } = await this.#invokeCommand(
       {
-        operationalDataset: import_general.Bytes.fromHex(this.commissioningOptions.threadNetwork.operationalDataset),
-        breadcrumb: this.lastBreadcrumb++
+        endpoint: RootEndpointNumber,
+        cluster: import_network_commissioning.NetworkCommissioning.Complete,
+        command: "addOrUpdateThreadNetwork",
+        fields: {
+          operationalDataset: import_general.Bytes.fromHex(this.commissioningOptions.threadNetwork.operationalDataset),
+          breadcrumb: this.lastBreadcrumb++
+        }
       },
-      { useExtendedFailSafeMessageResponseTimeout: true }
+      {
+        useExtendedFailSafeMessageResponseTimeout: true
+      }
     );
     if (addNetworkingStatus !== import_network_commissioning.NetworkCommissioning.NetworkCommissioningStatus.Success) {
       throw new ThreadNetworkSetupFailedError(`Commissionee failed to add Thread network: ${addDebugText}`);
@@ -918,7 +1115,15 @@ class ControllerCommissioningFlow {
     logger.debug(
       `Commissionee added Thread network ${this.commissioningOptions.threadNetwork.networkName} with network index ${networkIndex}`
     );
-    const updatedNetworks = await networkCommissioningClusterClient.getNetworksAttribute();
+    const updatedNetworks = await this.#readConcreteAttributeValues(
+      (0, import_Read.Read)(
+        import_Read.Read.Attribute({
+          endpoint: RootEndpointNumber,
+          cluster: import_network_commissioning.NetworkCommissioning.Complete,
+          attributes: ["networks"]
+        })
+      )
+    );
     if (updatedNetworks[networkIndex] === void 0) {
       throw new ThreadNetworkSetupFailedError(`Commissionee did not return network with index ${networkIndex}`);
     }
@@ -932,14 +1137,20 @@ class ControllerCommissioningFlow {
         breadcrumb: this.lastBreadcrumb
       };
     }
-    const connectMaxTime = (0, import_general.Seconds)(await networkCommissioningClusterClient.getConnectMaxTimeSecondsAttribute());
-    await this.#ensureFailsafeTimerFor(connectMaxTime);
-    const connectResult = await networkCommissioningClusterClient.connectNetwork(
+    await this.#ensureFailsafeTimerFor((0, import_general.Seconds)(connectMaxTimeSeconds));
+    const connectResult = await this.#invokeCommand(
       {
-        networkId,
-        breadcrumb: this.lastBreadcrumb++
+        endpoint: RootEndpointNumber,
+        cluster: import_network_commissioning.NetworkCommissioning.Complete,
+        command: "connectNetwork",
+        fields: {
+          networkId,
+          breadcrumb: this.lastBreadcrumb++
+        }
       },
-      { expectedProcessingTime: connectMaxTime }
+      {
+        expectedProcessingTime: (0, import_general.Seconds)(connectMaxTimeSeconds)
+      }
     );
     if (connectResult.networkingStatus !== import_network_commissioning.NetworkCommissioning.NetworkCommissioningStatus.Success) {
       throw new ThreadNetworkSetupFailedError(
@@ -989,7 +1200,7 @@ class ControllerCommissioningFlow {
     let transitionResult;
     try {
       transitionResult = await this.transitionToCase(
-        this.interactionClient.address,
+        this.interaction.address,
         // Assume concurrent connections are supported if not know (which should not be the case when we came here)
         isConcurrentFlow
       );
@@ -1004,7 +1215,7 @@ class ControllerCommissioningFlow {
         breadcrumb: this.lastBreadcrumb
       };
     }
-    this.interactionClient = transitionResult;
+    this.interaction = transitionResult;
     this.#clusterClients.clear();
     logger.debug("Successfully reconnected with device ...");
     return {
@@ -1020,12 +1231,18 @@ class ControllerCommissioningFlow {
    * the commissioning process.
    */
   async #completeCommissioning() {
-    const generalCommissioningClusterClient = this.#getClusterClient(import_general_commissioning.GeneralCommissioning.Cluster);
     this.#ensureGeneralCommissioningSuccess(
       "commissioningComplete",
-      await generalCommissioningClusterClient.commissioningComplete(void 0, {
-        useExtendedFailSafeMessageResponseTimeout: true
-      })
+      await this.#invokeCommand(
+        {
+          endpoint: RootEndpointNumber,
+          cluster: import_general_commissioning.GeneralCommissioning.Complete,
+          command: "commissioningComplete"
+        },
+        {
+          useExtendedFailSafeMessageResponseTimeout: true
+        }
+      )
     );
     this.#currentFailSafeEndTime = void 0;
     return {