@matter/node 0.16.0-alpha.0-20250926-3a74283f6 → 0.16.0-alpha.0-20250930-05e6cc3f8

package/src/behavior/system/network/ServerNetworkRuntime.ts

@@ -4,9 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { SubscriptionsBehavior } from "#behavior/system/subscriptions/SubscriptionsServer.js";
 import {
-    Construction,
     Crypto,
     InterfaceType,
     Logger,
@@ -65,7 +63,6 @@ export class ServerNetworkRuntime extends NetworkRuntime {
     #bleTransport?: TransportInterface;
     #ipv6UdpInterface?: UdpInterface;
     #observers = new ObserverGroup(this);
-    #formerSubscriptionsHandled = false;
     #groupNetworking?: ServerGroupNetworking;
 
     override get owner() {
@@ -205,7 +202,7 @@ export class ServerNetworkRuntime extends NetworkRuntime {
     /**
      * When the first Fabric gets added we need to enable MDNS broadcasting.
      */
-    enableMdnsAdvertising() {
+    ensureMdnsAdvertiser() {
         const device = this.owner.env.get(DeviceAdvertiser);
         const mdnsAdvertiser = this.mdnsAdvertiser;
         if (!device.hasAdvertiser(mdnsAdvertiser)) {
@@ -222,7 +219,7 @@ export class ServerNetworkRuntime extends NetworkRuntime {
     endUncommissionedMode() {
         // Ensure MDNS broadcasting are active when the first fabric is added.  It might not be active initially if the
         // node was not on an IP network prior to commissioning
-        this.enableMdnsAdvertising();
+        this.ensureMdnsAdvertiser();
 
         if (this.#bleAdvertiser) {
             this.owner.env.runtime.add(this.#deleteAdvertiser(this.#bleAdvertiser));
@@ -254,14 +251,16 @@ export class ServerNetworkRuntime extends NetworkRuntime {
         const { owner } = this;
         const { env } = owner;
 
-        // Ensure MdnsService is fully constructed
-        await env.load(MdnsService);
-
-        const advertiser = env.get(DeviceAdvertiser);
         // Configure network
         const interfaces = env.get(TransportInterfaceSet);
         await this.addTransports(interfaces);
         env.set(NetInterfaceSet, interfaces);
+
+        // Initialize MDNS
+        const mdns = await owner.env.load(MdnsService);
+
+        const advertiser = env.get(DeviceAdvertiser);
+
         await this.addBroadcasters(advertiser);
 
         await owner.act("start-network", agent => agent.load(ProductDescriptionServer));
@@ -291,29 +290,16 @@ export class ServerNetworkRuntime extends NetworkRuntime {
 
         // Enable MDNS broadcasting if there are fabrics present
         if (this.owner.stateOf(CommissioningServer).commissioned) {
-            this.enableMdnsAdvertising();
+            this.ensureMdnsAdvertiser();
         }
 
-        await this.owner.act(agent => this.owner.lifecycle.online.emit(agent.context));
-    }
-
-    override async [Construction.construct]() {
-        await super[Construction.construct]();
-
-        // Initialize MDNS
-        const mdns = await this.owner.env.load(MdnsService);
-
         // Initialize ScannerSet
         this.owner.env.get(ScannerSet).add(mdns.client);
-        this.owner.env.set(PeerAddressStore, new NodePeerAddressStore(this.owner));
-        await this.owner.env.load(PeerSet);
-
-        // Restore previous subscriptions
-        //
-        // TODO - move to SubscriptionsBehavior, and rename to SubscriptionsServer?
-        if (!this.#formerSubscriptionsHandled) {
-            await this.#reestablishFormerSubscriptions();
-        }
+
+        env.set(PeerAddressStore, new NodePeerAddressStore(owner));
+        await env.load(PeerSet);
+
+        await this.owner.act(agent => this.owner.lifecycle.online.emit(agent.context));
     }
 
     protected override async stop() {
@@ -349,18 +335,6 @@ export class ServerNetworkRuntime extends NetworkRuntime {
         this.owner.env.maybeGet(InteractionServer)?.blockNewActivity();
     }
 
-    async #reestablishFormerSubscriptions() {
-        const { env } = this.owner;
-        if (!env.has(InteractionServer)) {
-            return;
-        }
-        this.#formerSubscriptionsHandled = true;
-
-        await this.owner.act(agent =>
-            agent.get(SubscriptionsBehavior).reestablishFormerSubscriptions(env.get(InteractionServer)),
-        );
-    }
-
     async #initializeGroupNetworking() {
         if (this.#groupNetworking) {
             logger.warn("Group networking already initialized, skipping.");

package/src/behavior/system/subscriptions/SubscriptionsServer.ts

@@ -49,7 +49,7 @@ export class SubscriptionsBehavior extends Behavior {
         this.reactTo(sessions.events.subscriptionAdded, this.#addSubscription, { lock: true });
     }
 
-    static override schema = new DatatypeModel(
+    static override readonly schema = new DatatypeModel(
         {
             name: "SubscriptionState",
             type: "struct",
@@ -59,6 +59,8 @@ export class SubscriptionsBehavior extends Behavior {
                 name: "subscriptions",
                 type: "list",
                 quality: "N",
+                conformance: "M",
+                default: [],
             },
             FieldElement(
                 {
@@ -197,13 +199,14 @@ export class SubscriptionsBehavior extends Behavior {
         await this.context.transaction.commit();
     }
 
-    async reestablishFormerSubscriptions(interactionServer: InteractionServer) {
+    async reestablishFormerSubscriptions() {
         if (this.state.persistenceEnabled === false) return;
 
         // get and clear former subscriptions
         const { formerSubscriptions } = this.internal;
 
         if (!formerSubscriptions.length) {
+            logger.info("No former subscriptions to re-establish");
             return;
         } else {
             this.internal.formerSubscriptions = [];
@@ -211,6 +214,7 @@ export class SubscriptionsBehavior extends Behavior {
         }
         const peers = this.env.get(PeerSet);
         const sessions = this.env.get(SessionManager);
+        const interactionServer = this.env.get(InteractionServer);
 
         const peerStopList = new PeerAddressSet();
 
@@ -291,7 +295,7 @@ export namespace SubscriptionsBehavior {
          * List of subscriptions. This list is collected automatically.
          * The state value should not be initialized by the developer.
          */
-        subscriptions!: PeerSubscription[];
+        subscriptions: PeerSubscription[] = [];
     }
 
     export class Internal {

package/src/endpoint/properties/Endpoints.ts

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { IndexBehavior } from "#behavior/system/index/IndexBehavior.js";
+import type { Endpoint } from "#endpoint/Endpoint.js";
+import { EndpointType } from "#endpoint/type/EndpointType.js";
+import type { ImmutableSet } from "#general";
+import { Node } from "#node/Node.js";
+import { StatusResponse } from "#types";
+
+/**
+ * Access to all endpoints on a node, including the root endpoint.
+ */
+export class Endpoints implements ImmutableSet<Endpoint> {
+    #node: Node;
+
+    constructor(node: Node) {
+        this.#node = node;
+    }
+
+    has(endpoint: Endpoint | number): boolean {
+        if (endpoint === this.#node || endpoint === 0) {
+            return true;
+        }
+
+        if (typeof endpoint === "number") {
+            return endpoint in this.#index;
+        }
+
+        return endpoint.lifecycle.hasNumber && endpoint.number in this.#index;
+    }
+
+    get size(): number {
+        return this.#list.length + 1;
+    }
+
+    map<R>(mapper: (item: Endpoint<EndpointType.Empty>) => R): R[] {
+        return this.#list.map(mapper);
+    }
+
+    find(predicate: (item: Endpoint) => boolean | undefined): Endpoint | undefined {
+        return this.#list.find(predicate);
+    }
+
+    filter(predicate: (item: Endpoint) => boolean | undefined): Endpoint[] {
+        return this.#list.filter(predicate);
+    }
+
+    [Symbol.iterator]() {
+        return this.#list[Symbol.iterator]();
+    }
+
+    for(number: number): Endpoint {
+        if (number === 0) {
+            return this.#node;
+        }
+
+        const endpoint = this.#index[number];
+        if (endpoint === undefined) {
+            throw new StatusResponse.NotFoundError(`Endpoint ${number} does not exist`);
+        }
+        return endpoint;
+    }
+
+    /**
+     * Object mapping EndpointNumber -> Endpoint.
+     *
+     * Note that this does not include endpoint 0, but we have that in #node.
+     */
+    get #index() {
+        return this.#node.behaviors.internalsOf(IndexBehavior).partsByNumber;
+    }
+
+    /**
+     * Full list of endpoints.  Includes endpoint 0.
+     */
+    get #list() {
+        return [this.#node, ...Object.values(this.#index)];
+    }
+}

package/src/endpoint/properties/index.ts

@@ -9,5 +9,6 @@ export * from "./Commands.js";
 export * from "./EndpointContainer.js";
 export * from "./EndpointInitializer.js";
 export * from "./EndpointLifecycle.js";
+export * from "./Endpoints.js";
 export * from "./Parts.js";
 export * from "./SupportedBehaviors.js";

package/src/node/Node.ts

@@ -11,6 +11,7 @@ import { NetworkBehavior } from "#behavior/system/network/NetworkBehavior.js";
 import { NetworkRuntime } from "#behavior/system/network/NetworkRuntime.js";
 import { PartsBehavior } from "#behavior/system/parts/PartsBehavior.js";
 import { Endpoint } from "#endpoint/Endpoint.js";
+import { Endpoints } from "#endpoint/properties/Endpoints.js";
 import { EndpointType } from "#endpoint/type/EndpointType.js";
 import { MutableEndpoint } from "#endpoint/type/MutableEndpoint.js";
 import {
@@ -24,6 +25,7 @@ import {
     RuntimeService,
 } from "#general";
 import { Interactable } from "#protocol";
+import type { EndpointNumber } from "#types";
 import { RootEndpoint } from "../endpoints/root.js";
 import { NodeLifecycle } from "./NodeLifecycle.js";
 import { ProtocolService } from "./server/ProtocolService.js";
@@ -148,6 +150,16 @@ export abstract class Node<T extends Node.CommonRootEndpoint = Node.CommonRootEn
         await this.lifecycle.mutex.produce(this.cancelWithMutex.bind(this));
     }
 
+    /**
+     * All endpoints owned by the node.
+     *
+     * Normally you access endpoints via {@link parts} but you can use this property access endpoints directly by
+     * {@link EndpointNumber}.
+     */
+    get endpoints(): Endpoints {
+        return new Endpoints(this);
+    }
+
     protected async cancelWithMutex() {
         if (!this.#runtime) {
             return;