@matter/node 0.16.0-alpha.0-20251205-dfb1e1556 → 0.16.0-alpha.0-20251207-37e501b18

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

@@ -44,9 +44,7 @@ export abstract class NetworkRuntime {
     async [Construction.destruct]() {
         this.#abort();
         const activity = this.#owner.env.get(NodeActivity);
-        if (activity.isActive) {
-            await activity.inactive;
-        }
+        await activity.inactive;
 
         try {
             await this.stop();

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

@@ -48,7 +48,7 @@ export class ServerGroupNetworking {
         this.#observers.on(fabrics.events.added, async fabric => this.#registerFabricGroupObserver(fabric));
 
         // When fabric is deleted, we remove the group memberships
-        this.#observers.on(fabrics.events.deleted, async fabric => {
+        this.#observers.on(fabrics.events.deleting, async fabric => {
             const fabricIndex = fabric.fabricIndex;
             this.#observersForFabric(fabricIndex).close();
             this.#fabricObservers.delete(fabricIndex);
@@ -64,7 +64,7 @@ export class ServerGroupNetworking {
             this.#activeGroupMemberships.delete(fabricIndex);
         });
 
-        this.#observers.on(fabrics.events.updated, async fabric => {
+        this.#observers.on(fabrics.events.replaced, async fabric => {
             const fabricIndex = fabric.fabricIndex;
 
             this.#observersForFabric(fabricIndex).close();

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

@@ -24,7 +24,6 @@ import {
     Advertiser,
     Ble,
     BleAdvertiser,
-    ChannelManager,
     DeviceAdvertiser,
     DeviceCommissioner,
     ExchangeManager,
@@ -79,7 +78,10 @@ export class ServerNetworkRuntime extends NetworkRuntime {
     get mdnsAdvertiser() {
         if (!this.#mdnsAdvertiser) {
             const port = this.owner.state.network.operationalPort;
-            const options = this.owner.state.commissioning.mdns;
+            const options = {
+                lifetime: this.construction,
+                ...this.owner.state.commissioning.mdns,
+            };
             const crypto = this.owner.env.get(Crypto);
             const { server } = this.#services.get(MdnsService);
             this.#mdnsAdvertiser = new MdnsAdvertiser(crypto, server, { ...options, port });
@@ -119,7 +121,10 @@ export class ServerNetworkRuntime extends NetworkRuntime {
     protected get bleAdvertiser() {
         if (this.#bleAdvertiser === undefined) {
             const { peripheralInterface } = this.owner.env.get(Ble);
-            const options = this.owner.state.commissioning.ble;
+            const options = {
+                lifetime: this.construction,
+                ...this.owner.state.commissioning.ble,
+            };
             this.#bleAdvertiser = new BleAdvertiser(peripheralInterface, options);
         }
         return this.#bleAdvertiser;
@@ -269,9 +274,6 @@ export class ServerNetworkRuntime extends NetworkRuntime {
         await owner.act("start-network", agent => agent.load(ProductDescriptionServer));
 
         // Apply settings to environmental components
-        env.get(ChannelManager).caseSessionsPerFabricAndNode =
-            // Note that this is "sessions per fabric and node", so we support more than indicated by capabilityMinima
-            owner.state.basicInformation.capabilityMinima.caseSessionsPerFabric;
         env.get(SessionManager).sessionParameters = {
             maxPathsPerInvoke: this.owner.state.basicInformation.maxPathsPerInvoke,
         };
@@ -314,7 +316,11 @@ export class ServerNetworkRuntime extends NetworkRuntime {
 
         const { env } = this.owner;
 
-        await env.close(DeviceCommissioner);
+        {
+            using _lifetime = this.construction.join("commissioner");
+            await env.close(DeviceCommissioner);
+        }
+
         // Shutdown the Broadcaster if DeviceAdvertiser is not initialized
         // We kick-off the Advertiser shutdown to prevent re-announces when removing sessions and wait a bit later
         const advertisementShutdown = this.owner.env.has(DeviceAdvertiser)
@@ -322,21 +328,49 @@ export class ServerNetworkRuntime extends NetworkRuntime {
             : this.#mdnsAdvertiser?.close();
         this.#mdnsAdvertiser = undefined;
 
-        await this.owner.prepareRuntimeShutdown();
+        {
+            using _lifetime = this.construction.join("preparing");
+            await this.owner.prepareRuntimeShutdown();
+        }
 
         this.#groupNetworking?.close();
         this.#groupNetworking = undefined;
 
         // Now all sessions are closed, so we wait for Advertiser to be gone
-        await advertisementShutdown;
+        {
+            using _advertiser = this.construction.join("advertisement");
+            await advertisementShutdown;
+        }
+
+        {
+            using _lifetime = this.construction.join("services");
+            await this.#services.close();
+        }
+
+        {
+            using _lifetime = this.construction.join("exchanges");
+            await env.close(ExchangeManager);
+        }
+
+        {
+            using _lifetime = this.construction.join("protocols");
+            await env.close(SecureChannelProtocol);
+        }
 
-        await this.#services.close();
+        {
+            using _lifetime = this.construction.join("transports");
+            await env.close(ConnectionlessTransportSet);
+        }
 
-        await env.close(ExchangeManager);
-        await env.close(SecureChannelProtocol);
-        await env.close(ConnectionlessTransportSet);
-        await env.close(InteractionServer);
-        await env.close(PeerSet);
+        {
+            using _lifetime = this.construction.join("interactions");
+            await env.close(InteractionServer);
+        }
+
+        {
+            using _lifetime = this.construction.join("peers");
+            await env.close(PeerSet);
+        }
     }
 
     async #initializeGroupNetworking() {

package/src/behavior/system/remote/RemoteInterface.ts

@@ -4,7 +4,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Abort, AppAddress, BasicMultiplex, ImplementationError, Logger } from "#general";
+import {
+    Abort,
+    AppAddress,
+    BasicMultiplex,
+    decamelize,
+    ImplementationError,
+    Lifetime,
+    Logger,
+    Multiplex,
+} from "#general";
 import type { ServerNode } from "#node/ServerNode.js";
 import { ApiPath } from "./api/ApiPath.js";
 
@@ -15,10 +24,11 @@ const logger = Logger.get("RemoteAdapter");
  */
 export abstract class RemoteInterface {
     #node: ServerNode;
+    #lifetime: Lifetime;
     #address: AppAddress;
     #abort = new Abort();
     #root: ApiPath;
-    #workers = new BasicMultiplex();
+    #workers: Multiplex;
 
     constructor(node: ServerNode, address: AppAddress) {
         if (address.appProtocol !== (this.constructor as unknown as RemoteInterface.Type).protocol) {
@@ -27,10 +37,16 @@ export abstract class RemoteInterface {
             );
         }
         this.#node = node;
+        this.#lifetime = node.env.join(decamelize(this.constructor.name, " "));
+        this.#workers = new BasicMultiplex();
         this.#address = address;
         this.#root = new ApiPath(address);
     }
 
+    join(...name: unknown[]) {
+        return this.#lifetime.join(...name);
+    }
+
     get root() {
         return this.#root;
     }
@@ -75,6 +91,8 @@ export abstract class RemoteInterface {
             return;
         }
 
+        using _closing = this.#lifetime.closing();
+
         this.#abort();
 
         try {
@@ -92,8 +110,8 @@ export abstract class RemoteInterface {
         }
     }
 
-    protected addWorker(worker: Promise<void>, description: string) {
-        this.#workers.add(worker, description);
+    protected addWorker(worker: Promise<void>) {
+        this.#workers.add(worker);
     }
 
     static protocol = "";

package/src/behavior/system/remote/api/Api.ts

@@ -8,6 +8,7 @@ import { Agent } from "#endpoint/Agent.js";
 import { Abort, asError, Diagnostic, InternalError, Logger } from "#general";
 import { Node } from "#node/Node.js";
 import { ServerNode } from "#node/ServerNode.js";
+import { Mark } from "#protocol";
 import { StatusResponse, StatusResponseError } from "#types";
 import { ApiPath } from "./ApiPath.js";
 import { ApiResource } from "./ApiResource.js";
@@ -63,15 +64,15 @@ export namespace Api {
         if (!logger) {
             loggers.set(facility, (logger = Logger.get(facility)));
         }
-        logger[level](Diagnostic.via(id ?? "(anon)"), message);
+        logger[level](Diagnostic.via(id || "(anon)"), message);
     }
 
     export function logRequest(facility: string, id: string | undefined, method: string, target: string) {
-        log("info", facility, id, "«", Diagnostic.strong(method), target);
+        log("info", facility, id, Mark.INBOUND, Diagnostic.strong(method), target);
     }
 
     export function logResponse(facility: string, response: RemoteResponse) {
-        const message = Array<unknown>("»", RemoteResponse.describe(response));
+        const message = Array<unknown>(Mark.OUTBOUND, RemoteResponse.describe(response));
         let level: "error" | "info";
         switch (response.kind) {
             case "error":

package/src/behavior/system/sessions/SessionsBehavior.ts

@@ -30,11 +30,11 @@ export class SessionsBehavior extends Behavior {
 
     #convertToExposedSession(session: NodeSession): SessionsBehavior.Session {
         return {
-            name: session.name,
+            name: session.via,
             nodeId: session.nodeId,
             peerNodeId: session.peerNodeId,
             fabric: session.fabric?.externalInformation,
-            isPeerActive: session.isPeerActive(),
+            isPeerActive: session.isPeerActive,
             lastInteractionTimestamp: session.timestamp,
             lastActiveTimestamp: session.activeTimestamp,
             numberOfActiveSubscriptions: session.subscriptions.size,

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

@@ -9,12 +9,11 @@ import { DatatypeModel, FieldElement } from "#model";
 import { InteractionServer, PeerSubscription } from "#node/server/InteractionServer.js";
 import { ServerSubscription } from "#node/server/ServerSubscription.js";
 import {
-    ChannelManager,
-    NoChannelError,
     NodeDiscoveryType,
     PeerAddress,
     PeerAddressSet,
     PeerSet,
+    SessionClosedError,
     SessionManager,
     Subscription,
 } from "#protocol";
@@ -139,11 +138,11 @@ export class SubscriptionsBehavior extends Behavior {
         if (this.state.persistenceEnabled === false || !(subscription instanceof ServerSubscription)) return;
 
         const {
-            criteria: { attributeRequests, eventRequests, isFabricFiltered },
+            request: { attributeRequests, eventRequests, isFabricFiltered },
             session,
             maxInterval,
             sendInterval,
-            id,
+            subscriptionId: id,
             maxIntervalCeiling,
             minIntervalFloor,
         } = subscription;
@@ -153,11 +152,10 @@ export class SubscriptionsBehavior extends Behavior {
         // TODO Remove when we store peer addresses also for operational nodes
         let operationalAddress: ServerAddressUdp | undefined;
         try {
-            const channel = this.env.get(ChannelManager).getChannel(peerAddress, session).channel;
-            operationalAddress = isIpNetworkChannel(channel) ? channel.networkAddress : undefined;
+            operationalAddress = isIpNetworkChannel(session.channel) ? session.channel.networkAddress : undefined;
         } catch (error) {
             // Can happen in edge cases, so better catch it and proceed without operational address
-            NoChannelError.accept(error);
+            SessionClosedError.accept(error);
         }
         const peerSubscription: PeerSubscription = {
             subscriptionId: id,
@@ -184,7 +182,7 @@ export class SubscriptionsBehavior extends Behavior {
 
     #subscriptionCancelled(subscription: Subscription): MaybePromise {
         if (subscription.isCanceledByPeer && this.state.persistenceEnabled !== false) {
-            const { id } = subscription;
+            const { subscriptionId: id } = subscription;
             const subscriptionIndex = this.state.subscriptions.findIndex(({ subscriptionId }) => id === subscriptionId);
             if (subscriptionIndex !== -1) {
                 return this.#removeSubscriptionIndex(subscriptionIndex);
@@ -230,8 +228,10 @@ export class SubscriptionsBehavior extends Behavior {
                 logger.debug(`Skip reestablishing former subscription to ${peerAddress}`);
                 continue;
             }
-            logger.debug(`Try to reestablish former subscription ${subscriptionId} to ${peerAddress}`);
-            if (sessions.getSessionForNode(peerAddress) !== undefined) {
+            logger.debug(
+                `Try to reestablish former subscription ${Subscription.idStrOf(subscription)} to ${peerAddress}`,
+            );
+            if (sessions.maybeSessionFor(peerAddress) !== undefined) {
                 logger.debug(`We already have and existing session for peer ${peerAddress}`);
             } else {
                 try {
@@ -254,10 +254,12 @@ export class SubscriptionsBehavior extends Behavior {
             try {
                 if (peerStopList.has(peerAddress)) {
                     // To prevent concurrency issues, check again if there is a stop reason for this fabric
-                    logger.debug(`Skip re-establishing former subscription ${subscriptionId} to ${peerAddress}`);
+                    logger.debug(
+                        `Skip re-establishing former subscription ${Subscription.idStrOf(subscriptionId)} to ${peerAddress}`,
+                    );
                     continue;
                 }
-                const session = sessions.getSessionForNode(peerAddress);
+                const session = sessions.maybeSessionFor(peerAddress);
                 if (session === undefined) {
                     peerStopList.add(peerAddress);
                     logger.debug(`Could not connect to peer ${peerAddress}`);
@@ -266,7 +268,7 @@ export class SubscriptionsBehavior extends Behavior {
                 await interactionServer.establishFormerSubscription(subscription, session);
             } catch (error) {
                 logger.debug(
-                    `Failed to re-establish former subscription ${subscriptionId} to ${peerAddress}`,
+                    `Failed to re-establish former subscription ${Subscription.idStrOf(subscriptionId)} to ${peerAddress}`,
                     StatusResponseError.is(error)
                         ? error.code === StatusCode.InvalidSubscription
                             ? "Subscription no langer valid for peer"

package/src/behavior/system/websocket/WebSocketInterface.ts

@@ -116,10 +116,11 @@ export class WebSocketInterface extends RemoteInterface {
 
         await send({ id: request.id, kind: "ok" });
 
-        this.addWorker(this.#handleSubscription(response.stream, send), "ws subscription handler");
+        this.addWorker(this.#handleSubscription(response.stream, send));
     }
 
     async #handleSubscription(stream: LocalResponse.Stream, send: (message: LocalResponse) => Promise<void>) {
+        using _streaming = this.join("streaming");
         for await (const update of stream) {
             await send(update.js);
         }

package/src/behaviors/access-control/AccessControlServer.ts

@@ -87,7 +87,7 @@ export class AccessControlServer extends AccessControlBehavior.with("Extension")
         }
 
         // TODO handle delete fabric more generically later to remove fabric scoped data
-        this.reactTo(fabrics.events.updated, this.#updateFabricAcls);
+        this.reactTo(fabrics.events.replaced, this.#updateFabricAcls);
         this.reactTo(fabrics.events.added, this.#updateFabricAcls);
 
         this.reactTo(this.events.interactionBegin, this.#handleInteractionBegin);

package/src/behaviors/administrator-commissioning/AdministratorCommissioningServer.ts

@@ -4,8 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import type { RemoteActorContext } from "#behavior/context/server/RemoteActorContext.js";
 import { AdministratorCommissioning } from "#clusters/administrator-commissioning";
-import { Duration, InternalError, Logger, Seconds, Time, Timer } from "#general";
+import { Duration, InternalError, Logger, Seconds, Time, Timer, Worker } from "#general";
 import { AccessLevel } from "#model";
 import {
     assertRemoteActor,
@@ -138,14 +139,14 @@ export class AdministratorCommissioningServer extends AdministratorCommissioning
             );
         }
 
-        logger.debug("Revoking commissioning window.");
+        logger.debug("Revoking commissioning window");
 
         await this.#closeCommissioningWindow();
 
         if (this.env.has(FailsafeContext)) {
             const failsafeContext = this.env.get(FailsafeContext);
             if (failsafeContext) {
-                await failsafeContext.close();
+                await failsafeContext.close((this.context as RemoteActorContext).exchange);
             }
         }
     }
@@ -162,7 +163,7 @@ export class AdministratorCommissioningServer extends AdministratorCommissioning
             // Should never happen, but let's make sure
             throw new InternalError("Commissioning window already initialized.");
         }
-        const actor = hasRemoteActor(this.context) ? this.context.session.name : "local actor";
+        const actor = hasRemoteActor(this.context) ? this.context.session.via : "local actor";
         logger.debug(`Commissioning window timer started for ${commissioningTimeout} seconds for ${actor}.`);
         this.internal.commissioningWindowTimeout = Time.getTimer(
             "Commissioning timeout",
@@ -181,10 +182,10 @@ export class AdministratorCommissioningServer extends AdministratorCommissioning
         const removeCallback = this.callback(this.#fabricRemovedCallback);
 
         this.internal.stopMonitoringFabricForRemoval = () => {
-            adminFabric.deleteRemoveCallback(removeCallback);
+            adminFabric.deleting.off(removeCallback);
         };
 
-        this.context.session.associatedFabric.addRemoveCallback(removeCallback);
+        this.context.session.associatedFabric.deleting.on(removeCallback);
     }
 
     /**
@@ -236,6 +237,7 @@ export class AdministratorCommissioningServer extends AdministratorCommissioning
      * Closes the commissioning window per the matter specification.
      */
     async #closeCommissioningWindow() {
+        using _closing = this.lifetime.join("closing commissioning window");
         await this.env.get(DeviceCommissioner).endCommissioning();
     }
 
@@ -243,7 +245,12 @@ export class AdministratorCommissioningServer extends AdministratorCommissioning
      * Close commissioning window on timeout when there's nobody to await the resulting promise
      * */
     #commissioningTimeout() {
-        this.env.runtime.add(this.#closeCommissioningWindow());
+        this.env.runtime.add(
+            Worker({
+                name: "closing commissioning window",
+                done: this.#closeCommissioningWindow(),
+            }),
+        );
     }
 
     /**

package/src/behaviors/basic-information/BasicInformationServer.ts

@@ -117,7 +117,7 @@ export class BasicInformationServer extends Base {
         this.events.startUp.emit({ softwareVersion: this.state.softwareVersion }, this.context);
 
         const fabricManager = this.env.get(FabricManager);
-        this.reactTo(fabricManager.events.deleted, this.#handleRemovedFabric);
+        this.reactTo(fabricManager.events.leaving, this.#handleFabricLeave);
     }
 
     #goingOffline() {
@@ -128,7 +128,7 @@ export class BasicInformationServer extends Base {
         this.events.reachableChanged?.emit({ reachableNewValue: reachable }, this.context);
     }
 
-    #handleRemovedFabric({ fabricIndex }: Fabric) {
+    #handleFabricLeave({ fabricIndex }: Fabric) {
         this.events.leave.emit({ fabricIndex }, this.context);
     }
 }

package/src/behaviors/general-commissioning/GeneralCommissioningServer.ts

@@ -4,11 +4,12 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import type { RemoteActorContext } from "#behavior/context/server/RemoteActorContext.js";
 import { AdministratorCommissioningServer } from "#behaviors/administrator-commissioning";
 import { BasicInformationServer } from "#behaviors/basic-information";
 import { AdministratorCommissioning } from "#clusters/administrator-commissioning";
 import { GeneralCommissioning } from "#clusters/general-commissioning";
-import { Bytes, Diagnostic, Logger, MatterFlowError, MaybePromise, Seconds } from "#general";
+import { Bytes, Diagnostic, hex, Logger, MatterFlowError, MaybePromise, Seconds } from "#general";
 import type { ServerNode } from "#node/ServerNode.js";
 import {
     assertRemoteActor,
@@ -60,7 +61,7 @@ export class GeneralCommissioningServer extends GeneralCommissioningBehavior {
         ) {
             return;
         }
-        logger.debug(`New PASE session added: ${session.id}. Arming Failsafe for 60s.`);
+        logger.debug(session.via, `New PASE session, arming failsafe for 60s`);
         await this.#armFailSafe({ breadcrumb: this.state.breadcrumb, expiryLengthSeconds: 60 }, session);
     }
 
@@ -68,7 +69,7 @@ export class GeneralCommissioningServer extends GeneralCommissioningBehavior {
         { breadcrumb, expiryLengthSeconds }: GeneralCommissioning.ArmFailSafeRequest,
         session: SecureSession,
     ) {
-        NodeSession.assert(session, "armFailSafe can only be called on a secure session");
+        NodeSession.assert(session, "Failsafe may only be armed on a secure session");
         const commissioner = this.env.get(DeviceCommissioner);
 
         try {
@@ -84,11 +85,15 @@ export class GeneralCommissioningServer extends GeneralCommissioningBehavior {
                 !session.isPase
             ) {
                 // TODO - should this set status to Status.BusyWithOtherAdmin?
-                throw new MatterFlowError("Failed to arm failsafe using CASE while commissioning window is opened.");
+                throw new MatterFlowError("Cannot arm failsafe using CASE while commissioning window is opened");
             }
 
             if (commissioner.isFailsafeArmed) {
-                await commissioner.failsafeContext.extend(session.fabric, Seconds(expiryLengthSeconds));
+                await commissioner.failsafeContext.extend(
+                    session.fabric,
+                    Seconds(expiryLengthSeconds),
+                    (this.context as RemoteActorContext).exchange,
+                );
             } else {
                 // If ExpiryLengthSeconds is 0 and the fail-safe timer was not armed, then this command invocation SHALL
                 // lead to a success response with no side effect against the fail-safe context.
@@ -118,7 +123,7 @@ export class GeneralCommissioningServer extends GeneralCommissioningBehavior {
         } catch (error) {
             MatterFlowError.accept(error);
 
-            logger.debug(`Error while arming failSafe timer`, error);
+            logger.debug(`Error while arming failSafe timer:`, error);
             return {
                 errorCode: GeneralCommissioning.CommissioningError.BusyWithOtherAdmin,
                 debugText: error.message,
@@ -226,13 +231,13 @@ export class GeneralCommissioningServer extends GeneralCommissioningBehavior {
         }
         const failsafeContext = commissioner.failsafeContext;
 
-        SecureSession.assert(session, "commissioningComplete can only be called on a secure session");
+        SecureSession.assert(session, "Commissioning may only complete on a secure session");
 
         const timedFabric = failsafeContext.associatedFabric?.fabricIndex;
         if (fabric.fabricIndex !== timedFabric) {
             return {
                 errorCode: GeneralCommissioning.CommissioningError.InvalidAuthentication,
-                debugText: `Associated fabric ${fabric.fabricIndex} does not match the one from the failsafe context ${timedFabric}.`,
+                debugText: `Associated fabric index ${fabric.fabricIndex} does not match failsafe fabric index ${timedFabric}`,
             };
         }
 
@@ -252,7 +257,7 @@ export class GeneralCommissioningServer extends GeneralCommissioningBehavior {
             "Commissioned",
             Diagnostic.dict({
                 fabric: `${Bytes.toHex(fabric.operationalId)} (#${fabric.fabricIndex})`,
-                node: fabric.nodeId.toString(16).padStart(16, "0"),
+                node: hex.fixed(fabric.nodeId, 16),
             }),
         );
 

package/src/behaviors/general-commissioning/ServerNodeFailsafeContext.ts

@@ -8,7 +8,7 @@ import { NetworkCommissioningBehavior } from "#behaviors/network-commissioning";
 import { Endpoint } from "#endpoint/Endpoint.js";
 import { Immutable, Lifecycle, UnsupportedDependencyError } from "#general";
 import type { ServerNode } from "#node/ServerNode.js";
-import { Fabric, FabricManager, FailsafeContext } from "#protocol";
+import { FabricManager, FailsafeContext, MessageExchange } from "#protocol";
 
 /**
  * {@link FailsafeContext} for {@link ServerNode} API.
@@ -53,14 +53,8 @@ export class ServerNodeFailsafeContext extends FailsafeContext {
      * TODO - it's recommended to reset all state if commissioning bails; currently we perform mandatory restore
      */
     override async storeEndpointState() {
-        // const opcreds = this.#node.state.operationalCredentials;
         this.#storedState = {
             networks: new Map(),
-            /*
-            nocs: opcreds.nocs.map(noc => ({ ...noc })),
-            fabrics: opcreds.fabrics.map(fabric => ({ ...fabric })),
-            trustedRootCertificates: [...opcreds.trustedRootCertificates],
-             */
         };
 
         if (!this.#node.behaviors.has(NetworkCommissioningBehavior)) {
@@ -87,12 +81,6 @@ export class ServerNodeFailsafeContext extends FailsafeContext {
         });
     }
 
-    override async revokeFabric(fabric: Fabric) {
-        await fabric.remove();
-
-        // await this.#restoreOperationalCredentials();
-    }
-
     override async restoreBreadcrumb() {
         await this.#node.act(this.restoreBreadcrumb.name, async agent => {
             const tx = agent.context.transaction;
@@ -102,7 +90,7 @@ export class ServerNodeFailsafeContext extends FailsafeContext {
         });
     }
 
-    override async rollback() {
+    override async rollback(currentExchange?: MessageExchange) {
         if (!this.fabricIndex && this.hasRootCert) {
             // Update the fabric details if needed (like Trusted Root certificates) Only if fabric was not added because
             // else all data gets updated anyway
@@ -116,7 +104,7 @@ export class ServerNodeFailsafeContext extends FailsafeContext {
             }
         }
 
-        return super.rollback();
+        return super.rollback(currentExchange);
     }
 
     /*

package/src/behaviors/general-diagnostics/GeneralDiagnosticsServer.ts

@@ -308,7 +308,7 @@ export class GeneralDiagnosticsServer extends Base {
         this.internal.lastTotalOperationalHoursTimer = Time.getPeriodicTimer(
             "GeneralDiagnostics.operationalHours",
             Minutes(5),
-            this.callback(this.#updateTotalOperationalHoursCounter),
+            this.callback(this.#updateTotalOperationalHoursCounter, { lock: true }),
         ).start();
 
         await this.#updateNetworkList();

package/src/behaviors/group-key-management/GroupKeyManagementServer.ts

@@ -86,7 +86,7 @@ export class GroupKeyManagementServer extends GroupKeyManagementBehavior {
         // Added fabric always have no groups, so no need to initialize anything on adding the fabric
 
         // Fabric was updated, so basically newly created, so we need to reinitialize the group key sets
-        this.reactTo(fabrics.events.updated, this.#handleFabricUpdate);
+        this.reactTo(fabrics.events.replaced, this.#handleFabricUpdate);
 
         // When we have group key sets, we need to ensure that they are initialized on the Fabric group manager
         if (this.state.groupKeySets.length) {