@matter/node 0.16.0-alpha.0-20251212-4dde71be3 → 0.16.0-alpha.0-20251216-71c21f901

package/src/node/client/ClientStructure.ts

@@ -198,7 +198,7 @@ export class ClientStructure {
                         logger.debug(
                             "Received status for",
                             change.kind === "attr-status" ? "attribute" : "event",
-                            Diagnostic.strong(change.path.toString()),
+                            Diagnostic.strong(Diagnostic.dict(change.path)),
                             `: ${Status[change.status]}#${change.status}${change.clusterStatus !== undefined ? `/${Status[change.clusterStatus]}#${change.clusterStatus}` : ""}`,
                         );
                         break;
@@ -237,10 +237,18 @@ export class ClientStructure {
         await this.#emitPendingEvents();
     }
 
-    /** Reference to the default subscription used when the node was started. */
-    protected get subscribedFabricFiltered() {
+    /** Determines if the subscription is fabric filtered */
+    protected get subscribedFabricFiltered(): boolean {
         if (this.#subscribedFabricFiltered === undefined) {
-            this.#subscribedFabricFiltered = this.#node.state.network.defaultSubscription?.isFabricFiltered ?? true;
+            const defaultSubscription =
+                this.#node.state.network.defaultSubscription ??
+                ({} as { isFabricFiltered?: boolean; fabricFiltered?: boolean }); // Either Subscribe or Options
+            this.#subscribedFabricFiltered =
+                ("isFabricFiltered" in defaultSubscription
+                    ? defaultSubscription.isFabricFiltered
+                    : "fabricFiltered" in defaultSubscription
+                      ? defaultSubscription.fabricFiltered
+                      : true) ?? true;
             this.#node.events.network.defaultSubscription$Changed.on(newSubscription => {
                 this.#subscribedFabricFiltered = newSubscription?.isFabricFiltered ?? true;
             });
@@ -293,7 +301,7 @@ export class ClientStructure {
         const { endpointId, clusterId } = occurrence.path;
 
         const endpoint = this.#endpoints.get(endpointId);
-        // If we are building updates on current cluster or endpoint has pending changes, delay event emission
+        // If we are building updates on the current cluster or endpoint has pending changes, delay event emission
         if (
             (currentUpdates && (currentUpdates.endpointId === endpointId || currentUpdates.clusterId === clusterId)) ||
             (endpoint !== undefined && this.#pendingChanges?.has(endpoint))

package/src/node/client/Peers.ts

@@ -33,7 +33,15 @@ import {
 } from "#general";
 import { ClientGroup } from "#node/ClientGroup.js";
 import { InteractionServer } from "#node/server/InteractionServer.js";
-import { ClientSubscriptionHandler, ClientSubscriptions, FabricManager, PeerAddress, PeerSet } from "#protocol";
+import {
+    ClientSubscriptionHandler,
+    ClientSubscriptions,
+    FabricManager,
+    InteractionQueue,
+    PeerAddress,
+    PeerSet,
+    SessionManager,
+} from "#protocol";
 import { ServerNodeStore } from "#storage/server/ServerNodeStore.js";
 import { FabricIndex } from "@matter/types";
 import { ClientNode } from "../ClientNode.js";
@@ -53,9 +61,10 @@ const EXPIRATION_INTERVAL = Minutes.one;
  */
 export class Peers extends EndpointContainer<ClientNode> {
     #expirationInterval?: CancelablePromise;
-    #subscriptionHandler?: ClientSubscriptionHandler;
+    #installedSubscriptionHandler?: ClientSubscriptionHandler;
     #mutex = new Mutex(this);
     #closed = false;
+    #queue: InteractionQueue;
 
     constructor(owner: ServerNode) {
         super(owner);
@@ -66,6 +75,8 @@ export class Peers extends EndpointContainer<ClientNode> {
 
         owner.env.applyTo(InteractionServer, this.#configureInteractionServer.bind(this));
 
+        this.#queue = this.owner.env.get(InteractionQueue); // Queue is Node wide
+
         this.added.on(this.#handlePeerAdded.bind(this));
         this.deleted.on(this.#manageExpiration.bind(this));
 
@@ -117,16 +128,19 @@ export class Peers extends EndpointContainer<ClientNode> {
     }
 
     /**
-     * Find a specific commissionable node.
+     * Find a specific commissionable node, or, if no discovery options are provided, returns the first discovered node.
+     * TODO: Allow to provide an array of options for multiple discoveries (e.g. from a Multi QR code).
      */
     locate(options?: Discovery.Options) {
         return new InstanceDiscovery(this.owner, options);
     }
 
     /**
-     * Employ discovery to find a set of commissionable nodes.
+     * Employ discovery to find a set of commissionable nodes, the options can be used to limit the discovered devices
+     * (e.g. just a specific vendor).
+     * TODO: Allow to provide multiple identifiers for multiple discoveries (e.g. from a Multi QR code).
      *
-     * If you do not provide a timeout value, will search until canceled and you need to add a listener to
+     * If you do not provide a timeout value, will search until canceled, and you need to add a listener to
      * {@link Discovery#discovered} or {@link added} to receive discovered nodes.
      */
     discover(options?: Discovery.Options) {
@@ -161,14 +175,15 @@ export class Peers extends EndpointContainer<ClientNode> {
     /**
      * Emits when fixed attributes
      */
-
     override get(id: number | string | PeerAddress) {
         if (typeof id !== "string" && typeof id !== "number") {
             const address = PeerAddress(id);
             for (const node of this) {
-                const nodeAddress = node.state.commissioning.peerAddress;
-                if (nodeAddress && PeerAddress.is(nodeAddress, address)) {
-                    return node;
+                if (node.behaviors.active.some(({ id }) => id === "commissioning")) {
+                    const nodeAddress = node.maybeStateOf("commissioning")?.peerAddress as PeerAddress | undefined;
+                    if (nodeAddress !== undefined && PeerAddress.is(nodeAddress, address)) {
+                        return node;
+                    }
                 }
             }
             return undefined;
@@ -218,7 +233,8 @@ export class Peers extends EndpointContainer<ClientNode> {
 
     override async close() {
         this.#closed = true;
-        await this.#subscriptionHandler?.close();
+        this.#queue.close();
+        await this.#installedSubscriptionHandler?.close();
         this.#cancelExpiration();
         await this.#mutex;
         await super.close();
@@ -242,18 +258,19 @@ export class Peers extends EndpointContainer<ClientNode> {
      * If required, installs a listener in the environment's {@link InteractionServer} to handle subscription responses.
      */
     #configureInteractionServer() {
-        if (this.#closed || this.size > 0 || !this.owner.env.has(InteractionServer)) {
+        if (
+            this.#closed ||
+            this.#installedSubscriptionHandler !== undefined ||
+            !this.owner.env.has(InteractionServer)
+        ) {
             return;
         }
 
         const subscriptions = this.owner.env.get(ClientSubscriptions);
         const interactionServer = this.owner.env.get(InteractionServer);
 
-        if (!this.#subscriptionHandler) {
-            this.#subscriptionHandler = new ClientSubscriptionHandler(subscriptions);
-        }
-
-        interactionServer.clientHandler = this.#subscriptionHandler;
+        this.#installedSubscriptionHandler = new ClientSubscriptionHandler(subscriptions);
+        interactionServer.clientHandler = this.#installedSubscriptionHandler;
     }
 
     /**
@@ -281,6 +298,9 @@ export class Peers extends EndpointContainer<ClientNode> {
     }
 
     #onExpirationIntervalElapsed() {
+        if (this.#closed) {
+            return;
+        }
         this.#mutex.run(() =>
             this.#cullExpiredNodesAndAddresses()
                 .catch(error => {
@@ -297,7 +317,13 @@ export class Peers extends EndpointContainer<ClientNode> {
             const now = Time.nowMs;
 
             for (const node of this) {
-                const state = node.state.commissioning;
+                if (!node.lifecycle.isReady) {
+                    continue;
+                }
+                const state = node.maybeStateOf(CommissioningClient);
+                if (state === undefined) {
+                    continue;
+                }
                 const { addresses } = state;
                 const isCommissioned = state.peerAddress !== undefined;
 
@@ -358,6 +384,10 @@ export class Peers extends EndpointContainer<ClientNode> {
         node.eventsOf(type).capabilityMinima$Changed.on(setPeerLimits);
 
         function setPeerLimits() {
+            if (!node.env.has(PeerSet)) {
+                // Node is not yet online, delay setting limits
+                return;
+            }
             const peerAddress = node.maybeStateOf(CommissioningClient)?.peerAddress;
             if (peerAddress) {
                 node.env.get(PeerSet).for(peerAddress).limits = node.stateOf(type).capabilityMinima;
@@ -398,8 +428,15 @@ export class Peers extends EndpointContainer<ClientNode> {
         });
     }
 
-    #onShutdown(_node: ClientNode) {
-        // TODO
+    async #onShutdown(node: ClientNode) {
+        if (!node.lifecycle.isReady || !node.lifecycle.isOnline) {
+            return;
+        }
+        const peerAddress = node.maybeStateOf(CommissioningClient)?.peerAddress;
+        if (peerAddress !== undefined) {
+            // Shutdown event means the device reboots, handle it like a peer loss and remove all sessions
+            await this.owner.env.get(SessionManager).handlePeerShutdown(peerAddress);
+        }
     }
 }