@matter/node 0.17.2 → 0.17.3-alpha.0-20260617-ea3690abc

package/src/node/server/InteractionServer.ts

@@ -49,16 +49,16 @@ import {
 } from "@matter/protocol";
 import {
     AttributeData,
+    AttributePath,
     DEFAULT_MAX_PATHS_PER_INVOKE,
+    EventPath,
     INTERACTION_PROTOCOL_ID,
     InvokeResponseData,
     ReceivedStatusResponseError,
     Status,
     StatusResponseError,
     TlvAny,
-    TlvAttributePath,
     TlvClusterPath,
-    TlvEventPath,
     TlvInvokeResponseData,
     TlvInvokeResponseForSend,
     TlvSubscribeResponse,
@@ -75,17 +75,14 @@ export interface PeerSubscription {
     peerAddress: PeerAddress;
     minIntervalFloor: Duration;
     maxIntervalCeiling: Duration;
-    attributeRequests?: TypeFromSchema<typeof TlvAttributePath>[];
-    eventRequests?: TypeFromSchema<typeof TlvEventPath>[];
+    attributeRequests?: AttributePath[];
+    eventRequests?: EventPath[];
     isFabricFiltered: boolean;
     maxInterval: Duration;
     sendInterval: Duration;
 }
 
-function validateReadAttributesPath(path: TypeFromSchema<typeof TlvAttributePath>, isGroupSession = false) {
-    if (isGroupSession) {
-        throw new StatusResponseError("Illegal read request with group session", Status.InvalidAction);
-    }
+function validateReadAttributesPath(path: AttributePath) {
     const { clusterId, attributeId } = path;
     if (clusterId === undefined && attributeId !== undefined) {
         if (!GLOBAL_IDS.has(attributeId)) {
@@ -97,14 +94,17 @@ function validateReadAttributesPath(path: TypeFromSchema<typeof TlvAttributePath
     }
 }
 
-function validateReadEventPath(path: TypeFromSchema<typeof TlvEventPath>, isGroupSession = false) {
+function validateReadEventPath(path: EventPath) {
     const { clusterId, eventId } = path;
     if (clusterId === undefined && eventId !== undefined) {
         throw new StatusResponseError("Illegal read request with wildcard cluster ID", Status.InvalidAction);
     }
-    if (isGroupSession) {
-        throw new StatusResponseError("Illegal read request with group session", Status.InvalidAction);
-    }
+}
+
+/** Per Matter §8.4.3.2, Read and Subscribe share one valid-path algorithm. */
+function validateReadPaths(attributeRequests?: AttributePath[], eventRequests?: EventPath[]) {
+    attributeRequests?.forEach(path => validateReadAttributesPath(path));
+    eventRequests?.forEach(path => validateReadEventPath(path));
 }
 
 function clusterPathToId({ nodeId, endpointId, clusterId }: TypeFromSchema<typeof TlvClusterPath>) {
@@ -310,6 +310,8 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
             );
         }
 
+        validateReadPaths(attributeRequests, eventRequests);
+
         return {
             dataReport: {
                 interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
@@ -592,9 +594,7 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
             }),
         ]);
 
-        // Validate of the paths before proceeding
-        attributeRequests?.forEach(path => validateReadAttributesPath(path));
-        eventRequests?.forEach(path => validateReadEventPath(path));
+        validateReadPaths(attributeRequests, eventRequests);
 
         if (minIntervalFloorSeconds < 0) {
             throw new StatusResponseError(

package/src/node/server/ServerSubscription.ts

@@ -266,20 +266,25 @@ export class ServerSubscription implements Subscription {
         // controller minimum. But in general never faster than minimum interval configured or 2 seconds
         // (SUBSCRIPTION_MIN_INTERVAL_S). Additionally, we add a randomization window to the max interval to avoid all
         // devices sending at the same time. But we make sure not to exceed the global max interval.
-        const maxInterval = Duration.min(
-            Millis.floor(
-                Millis(
-                    Duration.max(
-                        subscriptionMinInterval,
+        // Spec §8.5.3.2 lower bound: MaxInterval must stay >= MinIntervalFloor even when the floor
+        // exceeds the publisher limit, so re-raise after the MAX_INTERVAL_PUBLISHER_LIMIT cap.
+        const maxInterval = Duration.max(
+            this.minIntervalFloor,
+            Duration.min(
+                Millis.floor(
+                    Millis(
                         Duration.max(
-                            this.minIntervalFloor,
-                            Duration.min(subscriptionMaxInterval, this.maxIntervalCeiling),
-                        ),
-                    ) +
-                        subscriptionRandomizationWindow * Math.random(),
+                            subscriptionMinInterval,
+                            Duration.max(
+                                this.minIntervalFloor,
+                                Duration.min(subscriptionMaxInterval, this.maxIntervalCeiling),
+                            ),
+                        ) +
+                            subscriptionRandomizationWindow * Math.random(),
+                    ),
                 ),
+                MAX_INTERVAL_PUBLISHER_LIMIT,
             ),
-            MAX_INTERVAL_PUBLISHER_LIMIT,
         );
         let sendInterval = Millis.floor(Millis(maxInterval / 2)); // Ideally we send at half the max interval
         if (sendInterval < Minutes.one) {
@@ -455,7 +460,7 @@ export class ServerSubscription implements Subscription {
                 break;
             }
 
-            this.#lastUpdateTime = Time.nowMs; // TODO Count time from here or from "receive of the ack"?
+            this.#lastUpdateTime = Time.nowMs;
 
             try {
                 using sending = updating?.join("sending");