@matter/node 0.16.0-alpha.0-20251115-d89e62680 → 0.16.0-alpha.0-20251129-96ad07c6e

package/src/behaviors/thermostat/ThermostatServer.ts

@@ -22,6 +22,8 @@ import {
     Observable,
 } from "#general";
 import { FieldElement } from "#model";
+import { Node } from "#node/index.js";
+import { ServerNode } from "#node/ServerNode.js";
 import { hasLocalActor, Val } from "#protocol";
 import { ClusterType, StatusResponse, TypeFromPartialBitSchema } from "#types";
 import { AtomicWriteHandler } from "./AtomicWriteHandler.js";
@@ -123,10 +125,11 @@ export class ThermostatBaseServer extends ThermostatBehaviorLogicBase {
             throw new ImplementationError("minSetpointDeadBand is out of valid range 0..127");
         }
 
+        const node = Node.forEndpoint(this.endpoint);
+        this.reactTo(node.lifecycle.online, this.#nodeOnline);
+
         // Initialize all the validation and logic handling
         this.#setupValidations();
-        this.#setupTemperatureMeasurementIntegration();
-        this.#setupOccupancyIntegration();
         this.#setupModeHandling();
         this.#setupThermostatLogic();
         this.#setupPresets();
@@ -136,6 +139,13 @@ export class ThermostatBaseServer extends ThermostatBehaviorLogicBase {
         this.internal.controlSequenceOfOperation = this.state.controlSequenceOfOperation;
     }
 
+    #nodeOnline() {
+        // TODO Also react to structure changes to add/remove endpoints that are being added or removed but might be used
+        //  for temperature or occupancy sensing
+        this.#setupTemperatureMeasurementIntegration();
+        this.#setupOccupancyIntegration();
+    }
+
     /**
      * The default implementation of the SetpointRaiseLower command. It handles all validation and setpoint adjustments
      * required by the Matter specification. This method only changes the Occupied setpoints.
@@ -415,20 +425,29 @@ export class ThermostatBaseServer extends ThermostatBehaviorLogicBase {
         }
 
         let localTemperature = null;
-        if (!preferRemoteTemperature && this.agent.has(TemperatureMeasurementServer)) {
-            logger.debug(
-                "Using existing TemperatureMeasurement cluster on same endpoint for local temperature measurement",
-            );
-            if (this.state.externalMeasuredIndoorTemperature !== undefined) {
+        const localTempEndpoint = this.state.localIndoorTemperatureMeasurementEndpoint;
+        if (!preferRemoteTemperature && localTempEndpoint !== undefined) {
+            const endpoints = this.env.get(ServerNode).endpoints;
+            const endpoint = endpoints.has(localTempEndpoint) ? endpoints.for(localTempEndpoint) : undefined;
+            if (endpoint !== undefined && endpoint.behaviors.has(TemperatureMeasurementServer)) {
+                logger.debug(
+                    `Using existing TemperatureMeasurement cluster on endpoint #${localTempEndpoint} for local temperature measurement`,
+                );
+                if (this.state.externalMeasuredIndoorTemperature !== undefined) {
+                    logger.warn(
+                        "Both local TemperatureMeasurement cluster and externalMeasuredIndoorTemperature state are set, using local cluster",
+                    );
+                }
+                this.reactTo(
+                    endpoint.eventsOf(TemperatureMeasurementServer).measuredValue$Changed,
+                    this.#handleMeasuredTemperatureChange,
+                );
+                localTemperature = endpoint.stateOf(TemperatureMeasurementServer).measuredValue;
+            } else {
                 logger.warn(
-                    "Both local TemperatureMeasurement cluster and externalMeasuredIndoorTemperature state are set, using local cluster",
+                    `No TemperatureMeasurement cluster found on endpoint #${localTempEndpoint}, falling back to externalMeasuredIndoorTemperature state if set`,
                 );
             }
-            this.reactTo(
-                this.agent.get(TemperatureMeasurementServer).events.measuredValue$Changed,
-                this.#handleMeasuredTemperatureChange,
-            );
-            localTemperature = this.endpoint.stateOf(TemperatureMeasurementServer).measuredValue;
         } else {
             if (this.state.externalMeasuredIndoorTemperature === undefined) {
                 logger.warn(
@@ -440,7 +459,9 @@ export class ThermostatBaseServer extends ThermostatBehaviorLogicBase {
             }
             this.reactTo(this.events.externalMeasuredIndoorTemperature$Changed, this.#handleMeasuredTemperatureChange);
         }
-        this.#handleMeasuredTemperatureChange(localTemperature); // and initialize
+        if (localTemperature !== null) {
+            this.#handleMeasuredTemperatureChange(localTemperature); // and initialize
+        }
     }
 
     /**
@@ -472,20 +493,30 @@ export class ThermostatBaseServer extends ThermostatBehaviorLogicBase {
         if (!this.features.occupancy) {
             return;
         }
-        let currentOccupancy: boolean;
+        let currentOccupancy = true;
         const preferRemoteOccupancy = !!this.state.remoteSensing?.occupancy;
-        if (!preferRemoteOccupancy && this.agent.has(OccupancySensingServer)) {
-            logger.debug("Using existing OccupancySensing cluster on same endpoint for local occupancy sensing");
-            if (this.state.externallyMeasuredOccupancy !== undefined) {
+        const localOccupancyEndpoint = this.state.localOccupancyMeasurementEndpoint;
+        if (!preferRemoteOccupancy && localOccupancyEndpoint !== undefined) {
+            const endpoints = this.env.get(ServerNode).endpoints;
+            const endpoint = endpoints.has(localOccupancyEndpoint) ? endpoints.for(localOccupancyEndpoint) : undefined;
+            if (endpoint !== undefined && endpoint.behaviors.has(OccupancySensingServer)) {
+                logger.debug(
+                    `Using existing OccupancySensing cluster on endpoint ${localOccupancyEndpoint} for local occupancy sensing`,
+                );
+                if (this.state.externallyMeasuredOccupancy !== undefined) {
+                    logger.warn(
+                        "Both local OccupancySensing cluster and externallyMeasuredOccupancy state are set, using local cluster",
+                    );
+                }
+                this.reactTo(endpoint.eventsOf(OccupancySensingServer).occupancy$Changed, this.#handleOccupancyChange);
+                currentOccupancy = !!endpoint.stateOf(OccupancySensingServer).occupancy.occupied;
+            } else {
                 logger.warn(
-                    "Both local OccupancySensing cluster and externallyMeasuredOccupancy state are set, using local cluster",
+                    `No OccupancySensing cluster found on endpoint ${localOccupancyEndpoint}, falling back to externallyMeasuredOccupancy state if set`,
                 );
             }
-            this.reactTo(this.agent.get(OccupancySensingServer).events.occupancy$Changed, this.#handleOccupancyChange);
-            currentOccupancy = !!this.endpoint.stateOf(OccupancySensingServer).occupancy.occupied;
         } else {
             if (this.state.externallyMeasuredOccupancy === undefined) {
-                currentOccupancy = true;
                 logger.warn(
                     "No local OccupancySensing cluster available and externallyMeasuredOccupancy state not set",
                 );
@@ -1354,6 +1385,12 @@ export namespace ThermostatBaseServer {
          */
         externalMeasuredIndoorTemperature?: number;
 
+        /**
+         * Endpoint (Number or string-Id) where to find the indoor temperature measurement cluster to use as
+         * local temperature measurement for the thermostat behavior.
+         */
+        localIndoorTemperatureMeasurementEndpoint?: number | string;
+
         /**
          * Otherwise measured occupancy as boolean.
          * Use this if you have an external occupancy sensor that should be used for thermostat control instead of a
@@ -1361,6 +1398,12 @@ export namespace ThermostatBaseServer {
          */
         externallyMeasuredOccupancy?: boolean;
 
+        /**
+         * Endpoint (Number or string-Id) where to find the occupancy sensing cluster to use as
+         * local occupancy measurement for the thermostat behavior.
+         */
+        localOccupancyMeasurementEndpoint?: number | string;
+
         /**
          * Use to enable the automatic mode management, implemented by this standard implementation.  This is beyond
          * Matter specification! It reacts to temperature changes to adjust system running mode automatically. It also

package/src/endpoint/Endpoint.ts

@@ -203,12 +203,12 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
     /**
      * Version of {@link stateOf} that returns undefined instead of throwing if the requested behavior unsupported.
      */
-    maybeStateOf(type: string): Immutable<Val.Struct>;
+    maybeStateOf(type: string): Immutable<Val.Struct> | undefined;
 
     /**
      * Version of {@link stateOf} that returns undefined instead of throwing if the requested behavior unsupported.
      */
-    maybeStateOf<T extends Behavior.Type>(type: T): Immutable<Behavior.StateOf<T>>;
+    maybeStateOf<T extends Behavior.Type>(type: T): Immutable<Behavior.StateOf<T>> | undefined;
 
     maybeStateOf(type: Behavior.Type | string) {
         if (typeof type === "string") {

package/src/endpoint/properties/Endpoints.ts

@@ -25,7 +25,7 @@ export class Endpoints implements ImmutableSet<Endpoint> {
         return this.#node;
     }
 
-    has(endpoint: Endpoint | number): boolean {
+    has(endpoint: Endpoint | number | string): boolean {
         if (endpoint === this.#node || endpoint === 0) {
             return true;
         }
@@ -34,6 +34,10 @@ export class Endpoints implements ImmutableSet<Endpoint> {
             return endpoint in this.#index;
         }
 
+        if (typeof endpoint === "string") {
+            return endpoint in this.#idIndex;
+        }
+
         return endpoint.lifecycle.hasNumber && endpoint.number in this.#index;
     }
 
@@ -57,12 +61,12 @@ export class Endpoints implements ImmutableSet<Endpoint> {
         return this.#list[Symbol.iterator]();
     }
 
-    for(number: number): Endpoint {
+    for(number: number | string): Endpoint {
         if (number === 0) {
             return this.#node;
         }
 
-        const endpoint = this.#index[number];
+        const endpoint = typeof number === "string" ? this.#idIndex[number] : this.#index[number];
         if (endpoint === undefined) {
             throw new StatusResponse.NotFoundError(`Endpoint ${number} does not exist`);
         }
@@ -78,6 +82,15 @@ export class Endpoints implements ImmutableSet<Endpoint> {
         return this.#node.behaviors.internalsOf(IndexBehavior).partsByNumber;
     }
 
+    /**
+     * Object mapping Endpoint-Id -> Endpoint.
+     *
+     * Note that this does not include endpoint 0, but we have that in #node.
+     */
+    get #idIndex() {
+        return this.#node.behaviors.internalsOf(IndexBehavior).partsById;
+    }
+
     /**
      * Full list of endpoints.  Includes endpoint 0.
      */

package/src/node/ClientNode.ts

@@ -110,22 +110,29 @@ export class ClientNode extends Node<ClientNode.RootEndpoint> {
 
     /**
      * Remove this node from the fabric (if commissioned) and locally.
+     * This method tries to communicate with the device to decommission it properly and will fail if the device is
+     * unreachable.
+     * If you can not reach the device, use {@link delete} instead.
      */
-    override async delete() {
+    async decommission() {
         if (this.lifecycle.isCommissioned) {
             this.statusUpdate("decommissioning");
 
             await this.act("decommission", agent => agent.commissioning.decommission());
         }
-
-        await super.delete();
+        await this.delete();
     }
 
     /**
      * Force-remove the node without first decommissioning.
      *
-     * If the node is still available you should use {@link delete} to remove it from the fabric.
+     * If the node is still available you should use {@link decommission} to remove it properly from the fabric and only use
+     * this method as fallback.  You should also tell the user that he needs to manually factory-reset the device.
      */
+    override async delete() {
+        await super.delete();
+    }
+
     override async erase() {
         await this.lifecycle.mutex.produce(this.eraseWithMutex.bind(this));
     }

package/src/node/Node.ts

@@ -40,6 +40,7 @@ const logger = Logger.get("Node");
 export abstract class Node<T extends Node.CommonRootEndpoint = Node.CommonRootEndpoint> extends Endpoint<T> {
     #environment: Environment;
     #runtime?: NetworkRuntime;
+    #startInProgress = false;
 
     constructor(config: Node.Configuration<T>) {
         const parentEnvironment = config.environment ?? config.owner?.env ?? Environment.default;
@@ -96,12 +97,18 @@ export abstract class Node<T extends Node.CommonRootEndpoint = Node.CommonRootEn
      * Bring the node online.
      */
     async start() {
-        if (this.lifecycle.isOnline) {
+        if (this.lifecycle.isOnline || this.#startInProgress) {
             return;
         }
-        this.lifecycle.targetState = "online";
 
-        await this.lifecycle.mutex.produce(this.startWithMutex.bind(this));
+        this.#startInProgress = true;
+        try {
+            this.lifecycle.targetState = "online";
+
+            await this.lifecycle.mutex.produce(this.startWithMutex.bind(this));
+        } finally {
+            this.#startInProgress = false;
+        }
     }
 
     protected async startWithMutex() {

package/src/node/NodeLifecycle.ts

@@ -103,7 +103,7 @@ export class NodeLifecycle extends EndpointLifecycle {
     }
 
     /**
-     * Emits when node is no longer comissioned.
+     * Emits when node is no longer commissioned.
      */
     get decommissioned() {
         return this.#decommissioned;

package/src/node/ServerNode.ts

@@ -105,13 +105,16 @@ export class ServerNode<T extends ServerNode.RootEndpoint = ServerNode.RootEndpo
     }
 
     override async [Construction.destruct]() {
+        if (this.#peers) {
+            await this.#peers.close();
+        }
+
         await super[Construction.destruct]();
         await ServerEnvironment.close(this);
     }
 
     override async prepareRuntimeShutdown() {
-        const sessions = this.env.get(SessionManager);
-        await sessions.close();
+        await this.env.get(SessionManager).closeAllSessions();
     }
 
     /**
@@ -160,8 +163,13 @@ export class ServerNode<T extends ServerNode.RootEndpoint = ServerNode.RootEndpo
      */
     get peers() {
         if (!this.#peers) {
-            this.#peers = new Peers(this);
-            this.#peers.initialize();
+            try {
+                this.#peers = new Peers(this);
+                this.#peers.initialize();
+            } catch (e) {
+                this.#peers = undefined;
+                throw e;
+            }
         }
 
         return this.#peers;

package/src/node/client/ClientEndpointInitializer.ts

@@ -59,7 +59,7 @@ export class ClientEndpointInitializer extends EndpointInitializer {
 
         // Activate remote behavior
         const store = this.structure.storeForRemote(endpoint, peerType);
-        return new ClientBehaviorBacking(endpoint, type, store, endpoint.behaviors.optionsFor(peerType));
+        return new ClientBehaviorBacking(endpoint, peerType, store, endpoint.behaviors.optionsFor(peerType));
     }
 
     get structure() {

package/src/node/client/ClientEventEmitter.ts

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

package/src/node/client/ClientStructure.ts

@@ -28,6 +28,7 @@ import { ReadScope, type Read, type ReadResult } from "#protocol";
 import { DatasourceCache } from "#storage/client/DatasourceCache.js";
 import { ClientNodeStore } from "#storage/index.js";
 import type { AttributeId, ClusterId, ClusterType, CommandId, EndpointNumber } from "#types";
+import { Status } from "#types";
 import { ClientEventEmitter } from "./ClientEventEmitter.js";
 import { ClientStructureEvents } from "./ClientStructureEvents.js";
 import { PeerBehavior } from "./PeerBehavior.js";
@@ -44,11 +45,12 @@ const PARTS_LIST_ATTR_ID = Descriptor.Cluster.attributes.partsList.id;
 export class ClientStructure {
     #nodeStore: ClientNodeStore;
     #endpoints = new Map<EndpointNumber, EndpointStructure>();
-    #emitEvent: ClientEventEmitter;
+    #eventEmitter: ClientEventEmitter;
     #node: ClientNode;
     #subscribedFabricFiltered?: boolean;
     #pendingChanges = new Map<EndpointStructure, PendingChange>();
-    #pendingEvents = Array<PendingEvent>();
+    #pendingStructureEvents = Array<PendingEvent>();
+    #delayedClusterEvents = new Array<ReadResult.EventValue>();
     #events: ClientStructureEvents;
 
     constructor(node: ClientNode) {
@@ -58,7 +60,7 @@ export class ClientStructure {
             endpoint: node,
             clusters: new Map(),
         });
-        this.#emitEvent = ClientEventEmitter(node, this);
+        this.#eventEmitter = ClientEventEmitter(node, this);
         this.#events = this.#node.env.get(ClientStructureEvents);
     }
 
@@ -103,7 +105,7 @@ export class ClientStructure {
             this.#install(structure);
         }
 
-        this.#emitPendingEvents();
+        this.#emitPendingStructureEvents();
     }
 
     /**
@@ -167,9 +169,6 @@ export class ClientStructure {
      * Update the node structure by applying attribute changes.
      */
     async *mutate(request: Read, changes: ReadResult) {
-        // Ensure mutations run serially and integrate properly with node lifecycle
-        using _lock = await this.#node.lifecycle.mutex.lock();
-
         // We collect updates and only apply when we transition clusters
         let currentUpdates: AttributeUpdates | undefined;
 
@@ -183,10 +182,18 @@ export class ClientStructure {
                         break;
 
                     case "event-value":
-                        this.#emitEvent(change);
+                        this.#emitEvent(change, currentUpdates);
                         break;
 
-                    // we ignore attr-status and event-status for now
+                    case "attr-status":
+                    case "event-status":
+                        logger.debug(
+                            "Received status for",
+                            change.kind === "attr-status" ? "attribute" : "event",
+                            Diagnostic.strong(change.path.toString()),
+                            `: ${Status[change.status]}#${change.status}${change.clusterStatus !== undefined ? `/${Status[change.clusterStatus]}#${change.clusterStatus}` : ""}`,
+                        );
+                        break;
                 }
             }
 
@@ -218,7 +225,7 @@ export class ClientStructure {
         }
 
         // Likewise, we don't emit events until we've applied all structural changes
-        this.#emitPendingEvents();
+        this.#emitPendingStructureEvents();
     }
 
     /** Reference to the default subscription used when the node was started. */
@@ -273,6 +280,21 @@ export class ClientStructure {
         return currentUpdates;
     }
 
+    #emitEvent(occurrence: ReadResult.EventValue, currentUpdates?: AttributeUpdates) {
+        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 (
+            (currentUpdates && (currentUpdates.endpointId === endpointId || currentUpdates.clusterId === clusterId)) ||
+            (endpoint !== undefined && this.#pendingChanges?.has(endpoint))
+        ) {
+            this.#delayedClusterEvents.push(occurrence);
+        } else {
+            this.#eventEmitter(occurrence);
+        }
+    }
+
     /**
      * Obtain the {@link ClusterType} for an {@link EndpointNumber} and {@link ClusterId}.
      */
@@ -308,13 +330,27 @@ export class ClientStructure {
         }
 
         if (cluster.behavior && AttributeList.id in attrs.values) {
-            if (!isDeepEqual(cluster.attributes, attrs.values[AttributeList.id])) {
+            const attributeList = attrs.values[AttributeList.id];
+            if (
+                Array.isArray(attributeList) &&
+                !isDeepEqual(
+                    cluster.attributes,
+                    attributeList.sort((a, b) => a - b),
+                )
+            ) {
                 cluster.behavior = undefined;
             }
         }
 
         if (cluster.behavior && AcceptedCommandList.id in attrs.values) {
-            if (!isDeepEqual(cluster.attributes, attrs.values[AttributeList.id])) {
+            const acceptedCommands = attrs.values[AcceptedCommandList.id];
+            if (
+                Array.isArray(acceptedCommands) &&
+                !isDeepEqual(
+                    cluster.commands,
+                    acceptedCommands.sort((a, b) => a - b),
+                )
+            ) {
                 cluster.behavior = undefined;
             }
         }
@@ -353,11 +389,15 @@ export class ClientStructure {
                 }
 
                 if (Array.isArray(attributeList)) {
-                    cluster.attributes = attributeList.filter(attr => typeof attr === "number") as AttributeId[];
+                    cluster.attributes = (attributeList.filter(attr => typeof attr === "number") as AttributeId[]).sort(
+                        (a, b) => a - b,
+                    );
                 }
 
                 if (Array.isArray(commandList)) {
-                    cluster.commands = commandList.filter(cmd => typeof cmd === "number") as CommandId[];
+                    cluster.commands = (commandList.filter(cmd => typeof cmd === "number") as CommandId[]).sort(
+                        (a, b) => a - b,
+                    );
                 }
             }
 
@@ -611,7 +651,7 @@ export class ClientStructure {
                     logger.error("Error clearing cluster storage:", e);
                 }
 
-                this.#pendingEvents.push({
+                this.#pendingStructureEvents.push({
                     kind: "cluster",
                     endpoint: structure,
                     cluster,
@@ -632,7 +672,7 @@ export class ClientStructure {
             cluster.behavior = pendingBehavior;
             delete cluster.pendingBehavior;
 
-            this.#pendingEvents.push({
+            this.#pendingStructureEvents.push({
                 kind: "cluster",
                 subkind,
                 endpoint: structure,
@@ -651,7 +691,7 @@ export class ClientStructure {
         if (pendingOwner) {
             endpoint.owner = pendingOwner.endpoint;
             structure.pendingOwner = undefined;
-            this.#pendingEvents.push({ kind: "endpoint", endpoint: structure });
+            this.#pendingStructureEvents.push({ kind: "endpoint", endpoint: structure });
         }
 
         // Handle behavior installation
@@ -672,7 +712,7 @@ export class ClientStructure {
             // We emit cluster events during the endpoint event so only add cluster event manually if the endpoint is
             // already installed
             if (!pendingOwner) {
-                this.#pendingEvents.push({
+                this.#pendingStructureEvents.push({
                     kind: "cluster",
                     subkind: "add",
                     endpoint: structure,
@@ -700,10 +740,12 @@ export class ClientStructure {
      * We do this after all structural updates are complete so that listeners can expect composed parts and dependent
      * behaviors to be installed.
      */
-    #emitPendingEvents() {
-        const events = this.#pendingEvents;
-        this.#pendingEvents = [];
-        for (const event of events) {
+    #emitPendingStructureEvents() {
+        const structureEvents = this.#pendingStructureEvents;
+        const clusterEvents = this.#delayedClusterEvents;
+        this.#delayedClusterEvents = [];
+        this.#pendingStructureEvents = [];
+        for (const event of structureEvents) {
             switch (event.kind) {
                 case "endpoint": {
                     const {
@@ -747,6 +789,9 @@ export class ClientStructure {
                 }
             }
         }
+        for (const occurrence of clusterEvents) {
+            this.#eventEmitter(occurrence);
+        }
     }
 }
 

package/src/node/client/Peers.ts

@@ -29,6 +29,7 @@ import {
     Seconds,
     Time,
     Timestamp,
+    UninitializedDependencyError,
 } from "#general";
 import { ClientGroup } from "#node/ClientGroup.js";
 import { InteractionServer } from "#node/server/InteractionServer.js";
@@ -69,6 +70,10 @@ export class Peers extends EndpointContainer<ClientNode> {
         this.deleted.on(this.#manageExpiration.bind(this));
 
         this.clusterInstalled(BasicInformationClient).on(this.#instrumentBasicInformation.bind(this));
+
+        const lifecycle = owner.lifecycle;
+        lifecycle.online.on(this.#nodeOnline.bind(this));
+        lifecycle.offline.on(this.#nodeOffline.bind(this));
     }
 
     /**
@@ -77,7 +82,14 @@ export class Peers extends EndpointContainer<ClientNode> {
     initialize() {
         const factory = this.owner.env.get(ClientNodeFactory);
 
-        const clientStores = this.owner.env.get(ServerNodeStore).clientStores;
+        const clientStores = this.owner.env.maybeGet(ServerNodeStore)?.clientStores;
+        if (clientStores === undefined) {
+            throw new UninitializedDependencyError(
+                "Peers",
+                "are not available because ServerNode initialization is incomplete",
+            );
+        }
+
         // Group nodes have an in-memory only store, so all nodes restored here are ClientNode
         for (const id of clientStores.knownIds) {
             this.add(
@@ -89,6 +101,21 @@ export class Peers extends EndpointContainer<ClientNode> {
         }
     }
 
+    async #nodeOnline() {
+        // TODO start all peers on node startup in a non blocking way respecting queuing for thread and such
+        /*for (const peer of this) {
+            await peer.start();
+        }*/
+        this.#manageExpiration();
+    }
+
+    async #nodeOffline() {
+        this.#cancelExpiration();
+        for (const peer of this) {
+            await peer.cancel();
+        }
+    }
+
     /**
      * Find a specific commissionable node.
      */
@@ -330,13 +357,13 @@ export class Peers extends EndpointContainer<ClientNode> {
 
     #onLeave(node: ClientNode, fabricIndex: FabricIndex) {
         this.#mutex.run(async () => {
-            const { fabrics: peerFabrics } = node.maybeStateOf(OperationalCredentialsClient);
-            const peerFabric = peerFabrics.find(fabric => fabric.fabricIndex === fabricIndex);
+            const { fabrics: peerFabrics } = node.maybeStateOf(OperationalCredentialsClient) ?? {};
+            const peerFabric = peerFabrics?.find(fabric => fabric.fabricIndex === fabricIndex);
             if (!peerFabric) {
                 return;
             }
 
-            const peerAddress = node.maybeStateOf(CommissioningClient).peerAddress;
+            const peerAddress = node.maybeStateOf(CommissioningClient)?.peerAddress;
             if (!peerAddress) {
                 return;
             }