@matter/node 0.17.7-alpha.0-20260724-baac832f7 → 0.17.7

package/src/node/NodePhysicalProperties.ts

@@ -12,6 +12,7 @@ import { IcdManagementClient } from "#behaviors/icd-management";
 import { NetworkCommissioningClient } from "#behaviors/network-commissioning";
 import { PowerSourceClient } from "#behaviors/power-source";
 import { ThreadNetworkDiagnosticsClient } from "#behaviors/thread-network-diagnostics";
+import { WiFiNetworkDiagnosticsClient } from "#behaviors/wi-fi-network-diagnostics";
 import { Endpoint } from "#endpoint/Endpoint.js";
 import { AggregatorEndpoint } from "#endpoints/aggregator";
 import { Node } from "#node/Node.js";
@@ -50,9 +51,57 @@ export function NodePhysicalProperties(node: Node) {
 
     inspectEndpoint(node, properties);
 
+    if (!properties.supportsWifi && !properties.supportsThread && !properties.supportsEthernet) {
+        inferNetworkMediumFromDiagnostics(node, properties);
+    }
+
     return properties;
 }
 
+/**
+ * Determine the operational medium of a node that reports no network interfaces via Network Commissioning ("commissioned
+ * by other means") from the network diagnostics cluster of the medium it operates on.
+ *
+ * The mandatory diagnostics attributes are all nullable and null while the interface is not associated, so a populated
+ * one distinguishes an operational interface from a cluster that merely exists.
+ *
+ * Diagnostics describe the node itself, so only the root endpoint is considered.
+ */
+function inferNetworkMediumFromDiagnostics(node: Node, properties: PhysicalDeviceProperties) {
+    const wifiDiagnosticsType = node.behaviors.typeFor(WiFiNetworkDiagnosticsClient);
+    const wifi = wifiDiagnosticsType ? node.maybeStateOf(wifiDiagnosticsType) : undefined;
+    if (wifi?.bssid !== undefined && wifi.bssid !== null) {
+        properties.supportsWifi = true;
+    }
+
+    const threadDiagnosticsType = node.behaviors.typeFor(ThreadNetworkDiagnosticsClient);
+    const thread = threadDiagnosticsType ? node.maybeStateOf(threadDiagnosticsType) : undefined;
+    if (
+        thread !== undefined &&
+        (isPresent(thread.extendedPanId) ||
+            isPresent(thread.panId) ||
+            isPresent(thread.channel) ||
+            isPresent(thread.networkName))
+    ) {
+        properties.supportsThread = true;
+
+        // A null extended PAN ID leaves threadActive false.  When Thread is the only medium the node reports we trust
+        // the remaining details instead, otherwise the node stays unclassified despite being reachable.
+        if (
+            !properties.supportsWifi &&
+            properties.wifiActive === undefined &&
+            properties.ethernetActive === undefined
+        ) {
+            properties.threadActive = true;
+            properties.threadChannel ??= thread.channel ?? undefined;
+        }
+    }
+}
+
+function isPresent(value: unknown) {
+    return value !== undefined && value !== null;
+}
+
 // Device types are collected node-wide (including bridged endpoints behind an aggregator) so consumers such as the
 // subscription-interval policy can react to them.  Power/network/thread properties describe the physical node itself,
 // so bridged endpoints (behindAggregator) must not contribute to them.

package/src/node/client/ClientStructure.ts

@@ -32,7 +32,6 @@ import {
     DeviceClassification,
     FeatureMap,
     GeneratedCommandList,
-    Matter,
     type FeatureBitmap,
 } from "@matter/model";
 import { ReadScope, Val, type Read, type ReadResult } from "@matter/protocol";
@@ -689,6 +688,7 @@ export class ClientStructure {
                 if (this.#commandFactory) {
                     shape.commandFactory = this.#commandFactory;
                 }
+                shape.matter = this.#node.matter;
                 const behaviorType = PeerBehavior(shape);
 
                 if (endpoint.lifecycle.isInstalled) {
@@ -730,7 +730,7 @@ export class ClientStructure {
                 }
 
                 let isApp = false;
-                const model = Matter.deviceTypes(dt.deviceType);
+                const model = this.#node.matter.deviceTypes(dt.deviceType);
                 if (model !== undefined) {
                     isApp = DeviceClassification.isApplication(model.classification);
                 }
@@ -917,7 +917,7 @@ export class ClientStructure {
         }
 
         // Try to resolve by looking up the cluster model by capitalized behavior name (e.g. "onOff" → "OnOff")
-        const clusterModel = Matter.clusters(capitalize(behaviorId));
+        const clusterModel = this.#node.matter.clusters(capitalize(behaviorId));
         if (clusterModel) {
             return this.#clusterFor(endpoint, clusterModel.id as ClusterId);
         }

package/src/node/client/PeerBehavior.ts

@@ -18,6 +18,7 @@ import {
     FeatureBitmap,
     FeatureSet,
     Matter,
+    MatterModel,
     type ValueModel,
 } from "@matter/model";
 import { AttributeId, ClusterId, CommandId } from "@matter/types";
@@ -25,7 +26,10 @@ import { ClientCommandMethod } from "./ClientCommandMethod.js";
 
 const BIT_BLOCK_SIZE = Math.log2(Number.MAX_SAFE_INTEGER);
 
-const discoveredCaches = new Map<ClusterBehaviorType.CommandFactory, Record<string, ClusterBehavior.Type>>();
+const discoveredCaches = new Map<
+    ClusterBehaviorType.CommandFactory,
+    WeakMap<MatterModel, Record<string, ClusterBehavior.Type>>
+>();
 const knownCaches = new Map<ClusterBehaviorType.CommandFactory, WeakMap<ClusterBehavior.Type, ClusterBehavior.Type>>();
 
 const isPeer = Symbol("is-peer");
@@ -73,6 +77,12 @@ export namespace PeerBehavior {
         commands?: CommandId[];
         generatedCommands?: CommandId[];
         commandFactory?: ClusterBehaviorType.CommandFactory;
+
+        /**
+         * Model used to resolve standard element names/shapes.  Defaults to the global {@link Matter} model; a client
+         * node supplies its own so custom or extended clusters resolve to real names.
+         */
+        matter?: MatterModel;
     }
 
     /**
@@ -86,12 +96,17 @@ export namespace PeerBehavior {
 }
 
 function instrumentDiscoveredShape(shape: PeerBehavior.DiscoveredClusterShape) {
-    const analysis = DiscoveredShapeAnalysis(shape);
+    const matter = shape.matter ?? Matter;
+    const analysis = DiscoveredShapeAnalysis(shape, matter);
     const factory = shape.commandFactory ?? ClientCommandMethod;
 
-    let cache = discoveredCaches.get(factory);
+    let byModel = discoveredCaches.get(factory);
+    if (!byModel) {
+        discoveredCaches.set(factory, (byModel = new WeakMap()));
+    }
+    let cache = byModel.get(matter);
     if (!cache) {
-        discoveredCaches.set(factory, (cache = {}));
+        byModel.set(matter, (cache = {}));
     }
 
     const fingerprint = createFingerprint(analysis);
@@ -102,7 +117,7 @@ function instrumentDiscoveredShape(shape: PeerBehavior.DiscoveredClusterShape) {
 
     // Find a base behavior for the standard cluster, if available
     let baseType: Behavior.Type | undefined;
-    const standardSchema = Matter.get(ClusterModel, shape.id);
+    const standardSchema = matter.get(ClusterModel, shape.id);
     if (standardSchema) {
         // Create a base behavior from the standard schema
         baseType = ClusterBehaviorType({
@@ -360,8 +375,11 @@ interface DiscoveredShapeAnalysis {
 /**
  * Analyze a discovered cluster shape to determine how we should override the behavior and schema.
  */
-function DiscoveredShapeAnalysis(shape: PeerBehavior.DiscoveredClusterShape): DiscoveredShapeAnalysis {
-    const standardCluster = Matter.clusters(shape.id);
+function DiscoveredShapeAnalysis(
+    shape: PeerBehavior.DiscoveredClusterShape,
+    matter: MatterModel = Matter,
+): DiscoveredShapeAnalysis {
+    const standardCluster = matter.clusters(shape.id);
     const schema =
         standardCluster ??
         new ClusterModel({ id: shape.id, name: createUnknownName("Cluster", shape.id), revision: shape.revision });