@matter/node 0.16.0-alpha.0-20251030-e9ca79f93 → 0.16.0-alpha.0-20251101-70c8d51d7

package/src/node/client/ClientEventEmitter.ts

@@ -5,7 +5,7 @@
  */
 
 import type { ElementEvent, Events } from "#behavior/Events.js";
-import { camelize, Logger } from "#general";
+import { camelize, Diagnostic, Logger } from "#general";
 import { ClusterModel, EventModel, MatterModel } from "#model";
 import type { ClientNode } from "#node/ClientNode.js";
 import type { ReadResult } from "#protocol";
@@ -46,7 +46,7 @@ export function ClientEventEmitter(node: ClientNode, structure: ClientStructure)
             return;
         }
 
-        const event = getEvent(occurrence.path.endpointId, names.cluster, names.event);
+        const event = getEvent(node, occurrence.path.endpointId, names.cluster, names.event);
         if (event) {
             node.act(agent => {
                 // Current ActionContext is not writable, could skip act() but meh, see TODO above
@@ -56,26 +56,27 @@ export function ClientEventEmitter(node: ClientNode, structure: ClientStructure)
         }
     }
 
-    function getEvent(endpointId: EndpointNumber, clusterName: string, eventName: string) {
+    function getEvent(node: ClientNode, endpointId: EndpointNumber, clusterName: string, eventName: string) {
         const endpoint = structure.endpointFor(endpointId);
         if (endpoint === undefined) {
-            logger.error(`Received event for unsupported endpoint #${endpointId}`);
+            logger.warn(`Received event for unsupported endpoint #${endpointId} on ${node}`);
             return;
         }
 
         const events = (endpoint.events as Events.Generic<ElementEvent>)[clusterName];
         if (events === undefined) {
-            logger.error(`Received event ${eventName} for unsupported cluster ${clusterName} on ${endpoint}`);
+            logger.warn(`Received event ${eventName} for unsupported cluster ${clusterName} on ${endpoint}`);
             return;
         }
 
-        const event = events[eventName];
-        if (event === undefined) {
-            logger.error(`Received unsupported event ${eventName} for cluster ${clusterName} on ${endpoint}`);
-            return;
-        }
+        logger.info(
+            "Received event",
+            Diagnostic.strong(`${clusterName}.${eventName}`),
+            " on ",
+            Diagnostic.strong(endpoint.toString()),
+        );
 
-        return event;
+        return events[eventName];
     }
 }
 

package/src/node/client/ClientNodeInteraction.ts

@@ -10,11 +10,11 @@ import type { ClientNode } from "#node/ClientNode.js";
 import {
     ClientInteraction,
     ClientInvoke,
+    ClientSubscribe,
     DecodedInvokeResult,
     Interactable,
     Read,
     ReadResult,
-    Subscribe,
     SubscribeResult,
     Write,
     WriteResult,
@@ -45,13 +45,19 @@ export class ClientNodeInteraction implements Interactable<ActionContext> {
     }
 
     /**
-     * Subscribe to chosen attributes remotely from the node. Data are automatically updated in the storage and not
-     * returned. The subscription response message with the subscription id and the maxInterval is returned.
+     * Subscribe to remote events and attributes as defined by {@link request}.
+     *
+     * matter.js updates local state
+     *
+     * By default matter.js subscribes to all attributes and events of the peer and updates {@link ClientNode} state
+     * automatically.  So you normally do not need to subscribe manually.
      */
-    async subscribe(request: Subscribe, context?: ActionContext): SubscribeResult {
-        const intermediateRequest: Subscribe = {
+    async subscribe(request: ClientSubscribe, context?: ActionContext): SubscribeResult {
+        const intermediateRequest: ClientSubscribe = {
             ...this.structure.injectVersionFilters(request),
 
+            sustain: request.sustain === undefined ? true : request.sustain,
+
             updated: async data => {
                 const result = this.structure.mutate(request, data);
                 if (request.updated) {
@@ -61,20 +67,10 @@ export class ClientNodeInteraction implements Interactable<ActionContext> {
                 }
             },
 
-            closed(cause) {
-                // TODO - log cause?
-                request.closed?.(cause);
-            },
+            closed: request.closed?.bind(request),
         };
-        const interaction = await this.#connect();
-        return interaction.subscribe(intermediateRequest, context);
-    }
 
-    cancelSubscription(id: number): void {
-        if (!this.#node.lifecycle.isOnline) {
-            return;
-        }
-        this.#node.env.get(ClientInteraction).cancelSubscription(id);
+        return (await this.#connect()).subscribe(intermediateRequest, context);
     }
 
     /**

package/src/node/integration/ChangeNotificationService.ts

@@ -71,7 +71,7 @@ export class ChangeNotificationService {
                         kind: "delete",
                         endpoint,
                     });
-                    if (endpoint == node) {
+                    if (endpoint === node) {
                         observers.close();
                         this.#observers.delete(node);
                     }

package/src/node/server/InteractionServer.ts

@@ -518,7 +518,7 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
             );
         } catch (error) {
             logger.error(
-                `Subscription ${subscriptionId} for Session ${session.id}: Error while sending initial data reports`,
+                `Subscription ${subscriptionId} for Session ${session.id}: Error while sending initial data reports:`,
                 error instanceof MatterError ? error.message : error,
             );
             if (error instanceof StatusResponseError && !(error instanceof ReceivedStatusResponseError)) {

package/src/node/server/OnlineServerInteraction.ts

@@ -35,10 +35,6 @@ export class OnlineServerInteraction implements Interactable<RemoteActorContext.
         throw new NotImplementedError("subscribe not implemented");
     }
 
-    cancelSubscription(_id: number): void {
-        throw new NotImplementedError("cancelSubscription not implemented");
-    }
-
     async write<T extends Write>(request: T, context: RemoteActorContext.Options): WriteResult<T> {
         return RemoteActorContext(context).act(session => this.#interaction.write(request, session));
     }