@matter/node 0.16.0-alpha.0-20251205-dfb1e1556 → 0.16.0-alpha.0-20251209-d6072d23e

package/src/behaviors/operational-credentials/OperationalCredentialsServer.ts

@@ -19,7 +19,6 @@ import {
     DeviceCertification,
     DeviceCommissioner,
     Fabric,
-    FabricAction,
     FabricManager,
     FabricTableFullError,
     MatterFabricConflictError,
@@ -269,19 +268,13 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
             return this.#mapNocErrors(error);
         }
 
-        // The receiver SHALL create and add a new Access Control Entry using the CaseAdminSubject field to grant
-        // subsequent Administer access to an Administrator member of the new Fabric.
-        await this.endpoint.act(agent => agent.get(AccessControlServer).addDefaultCaseAcl(fabric, [caseAdminSubject]));
-
         const session = this.context.session;
         NodeSession.assert(session);
 
-        await failsafeContext.addFabric(fabric);
-
         try {
             if (session.isPase) {
-                logger.debug(`Add Fabric ${fabric.fabricIndex} to PASE session ${session.name}`);
-                session.addAssociatedFabric(fabric);
+                logger.debug(`Add Fabric ${fabric.fabricIndex} to PASE session ${session.via}`);
+                session.fabric = fabric;
             }
 
             // Update attributes
@@ -294,10 +287,14 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
             }
         } catch (e) {
             // Fabric insertion into FabricManager is not currently transactional so we need to remove manually
-            await fabric.remove(session.id);
+            await fabric.delete(this.context.exchange);
             throw e;
         }
 
+        // The receiver SHALL create and add a new Access Control Entry using the CaseAdminSubject field to grant
+        // subsequent Administer access to an Administrator member of the new Fabric.
+        await this.endpoint.act(agent => agent.get(AccessControlServer).addDefaultCaseAcl(fabric, [caseAdminSubject]));
+
         // TODO The incoming IPKValue SHALL be stored in the Fabric-scoped slot within the Group Key Management cluster
         //  (see KeySetWrite), for subsequent use during CASE.
 
@@ -363,7 +360,7 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
             const updatedFabric = await timedOp.buildUpdatedFabric(nocValue, icacValue);
 
             // update FabricManager and Resumption records but leave current session intact
-            await timedOp.updateFabric(updatedFabric);
+            await timedOp.replaceFabric(updatedFabric);
 
             return {
                 statusCode: OperationalCredentials.NodeOperationalCertStatus.Ok,
@@ -397,7 +394,7 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
     override async removeFabric({ fabricIndex }: OperationalCredentials.RemoveFabricRequest) {
         assertRemoteActor(this.context);
 
-        const fabric = this.env.get(FabricManager).findByIndex(fabricIndex);
+        const fabric = this.env.get(FabricManager).maybeForIndex(fabricIndex);
 
         if (fabric === undefined) {
             return {
@@ -406,7 +403,11 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
             };
         }
 
-        await fabric.leave(this.context.session.id);
+        // We do not handle fabric management transactionally because of legacy FabricManager implementation, and if
+        // we leave the transaction open it will cause deadlock
+        await this.context.transaction.rollback();
+
+        await fabric.leave(this.context.exchange);
         // The state is updated on removal via commissionedFabricChanged event, see constructor
 
         return {
@@ -507,6 +508,9 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
     }
 
     async #updateFabrics() {
+        await this.context.transaction.addResources(this);
+        await this.context.transaction.begin();
+
         const fabrics = this.env.get(FabricManager);
         this.state.fabrics = fabrics.map(fabric => ({
             fabricId: fabric.fabricId,
@@ -548,17 +552,17 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
 
     async #handleAddedFabric({ fabricIndex }: Fabric) {
         await this.#updateFabrics();
-        this.agent.get(CommissioningServer).handleFabricChange(fabricIndex, FabricAction.Added);
+        this.agent.get(CommissioningServer).handleFabricChange(fabricIndex, "added");
     }
 
     async #handleUpdatedFabric({ fabricIndex }: Fabric) {
         await this.#updateFabrics();
-        this.agent.get(CommissioningServer).handleFabricChange(fabricIndex, FabricAction.Updated);
+        this.agent.get(CommissioningServer).handleFabricChange(fabricIndex, "updated");
     }
 
     async #handleRemovedFabric({ fabricIndex }: Fabric) {
         await this.#updateFabrics();
-        this.agent.get(CommissioningServer).handleFabricChange(fabricIndex, FabricAction.Removed);
+        this.agent.get(CommissioningServer).handleFabricChange(fabricIndex, "deleted");
     }
 
     async #handleFailsafeClosed() {
@@ -568,8 +572,8 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
     async #nodeOnline() {
         const fabricManager = this.env.get(FabricManager);
         this.reactTo(fabricManager.events.added, this.#handleAddedFabric, { lock: true });
-        this.reactTo(fabricManager.events.updated, this.#handleUpdatedFabric, { lock: true });
-        this.reactTo(fabricManager.events.deleted, this.#handleRemovedFabric, { lock: true });
+        this.reactTo(fabricManager.events.replaced, this.#handleUpdatedFabric, { lock: true });
+        this.reactTo(fabricManager.events.deleting, this.#handleRemovedFabric, { lock: true });
         this.reactTo(fabricManager.events.failsafeClosed, this.#handleFailsafeClosed, { lock: true });
         await this.#updateFabrics();
     }
@@ -582,7 +586,6 @@ export class OperationalCredentialsServer extends OperationalCredentialsBehavior
 export namespace OperationalCredentialsServer {
     export class Internal {
         certification?: DeviceCertification;
-        commissionedFabric?: FabricIndex;
     }
 
     export class State extends OperationalCredentialsBehavior.State {

package/src/behaviors/scenes-management/ScenesManagementServer.ts

@@ -218,7 +218,7 @@ export class ScenesManagementServer extends ScenesManagementBase {
 
         // When a fabric git removed we need to check if the active scene is considered from that fabric
         // Data cleanup happens automatically
-        this.reactTo(fabricManager.events.deleted, this.#handleDeleteFabric);
+        this.reactTo(fabricManager.events.deleting, this.#handleDeleteFabric);
     }
 
     /**

package/src/behaviors/thermostat/AtomicWriteHandler.ts

@@ -48,7 +48,7 @@ export class AtomicWriteHandler {
     #pendingWrites = new BasicSet<AtomicWriteState>();
 
     constructor(fabricManager: FabricManager) {
-        this.#observers.on(fabricManager.events.deleted, fabric => this.#handleFabricRemoval(fabric));
+        this.#observers.on(fabricManager.events.deleting, fabric => this.#handleFabricRemoval(fabric));
     }
 
     static [Environmental.create](env: Environment) {

package/src/behaviors/window-covering/WindowCoveringServer.ts

@@ -5,7 +5,7 @@
  */
 
 import { WindowCovering } from "#clusters/window-covering";
-import { Diagnostic, ImplementationError, isDeepEqual, Logger, MaybePromise } from "#general";
+import { Diagnostic, ImplementationError, isDeepEqual, Logger, MaybePromise, Worker } from "#general";
 import { ClusterType, StatusCode, StatusResponseError, TypeFromPartialBitSchema } from "#types";
 import { WindowCoveringBehavior } from "./WindowCoveringBehavior.js";
 
@@ -383,7 +383,13 @@ export class WindowCoveringBaseServer extends WindowCoveringBase {
      */
     #prepareMovement(type: MovementType, direction: MovementDirection, targetPercent100ths?: number): void {
         if (this.internal.supportsCalibration && this.internal.calibrationMode === CalibrationMode.Enabled) {
-            return this.env.runtime.add(this.#executeCalibrationAndMove(type, direction, targetPercent100ths));
+            return this.env.runtime.add(
+                Worker({
+                    name: `calibrating ${this}`,
+                    done: this.#executeCalibrationAndMove(type, direction, targetPercent100ths),
+                    lifetime: this.lifetime,
+                }),
+            );
         }
         if (type === MovementType.Lift && this.state.configStatus.liftMovementReversed) {
             logger.debug("Lift movement is reversed");
@@ -439,14 +445,22 @@ export class WindowCoveringBaseServer extends WindowCoveringBase {
                 break;
         }
 
-        this.env.runtime.add(
-            this.handleMovement(
-                type,
-                type === MovementType.Lift && !!this.state.configStatus.liftMovementReversed,
-                direction,
-                targetPercent100ths,
-            ),
+        const done = this.handleMovement(
+            type,
+            type === MovementType.Lift && !!this.state.configStatus.liftMovementReversed,
+            direction,
+            targetPercent100ths,
         );
+
+        if (done) {
+            this.env.runtime.add(
+                Worker({
+                    name: `moving ${this}`,
+                    done,
+                    lifetime: this.lifetime,
+                }),
+            );
+        }
     }
 
     #executeCalibrationAndMove(type: MovementType, direction: MovementDirection, targetPercent100ths?: number) {
@@ -455,6 +469,7 @@ export class WindowCoveringBaseServer extends WindowCoveringBase {
             this.internal.calibrationMode = CalibrationMode.Running;
             calibration = this.executeCalibration();
         }
+
         return MaybePromise.then(calibration, () => {
             this.internal.calibrationMode = CalibrationMode.Disabled;
             return this.#prepareMovement(type, direction, targetPercent100ths);

package/src/endpoint/Endpoint.ts

@@ -16,6 +16,7 @@ import {
     Immutable,
     ImplementationError,
     Lifecycle,
+    Lifetime,
     Logger,
     MaybePromise,
     Observable,
@@ -713,7 +714,7 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
             context => {
                 return actor(this.agentFor(context));
             },
-            { activity: this.#activity },
+            { activity: this.#activity, lifetime: this.construction },
         );
     }
 
@@ -721,18 +722,29 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
      * Perform "soft" reset of the endpoint, reverting all in-memory structures to uninitialized.
      */
     async reset() {
+        using _resetting = this.construction.join("resetting");
+
         try {
             // Revert lifecycle to uninitialized
             this.lifecycle.resetting();
 
             // Reset child parts
-            await this.parts.reset();
+            {
+                using _parts = _resetting.join("parts");
+                await this.parts.reset();
+            }
 
             // Reset behaviors
-            await this.behaviors.close();
+            {
+                using _behaviors = _resetting.join("behaviors");
+                await this.behaviors.close();
+            }
 
             // Notify
-            await this.lifecycle.reset.emit();
+            {
+                using _lifecycle = _resetting.join("lifecycle");
+                await this.lifecycle.reset.emit();
+            }
 
             // Set construction to inactive so we can restart
             this.construction.setStatus(Lifecycle.Status.Inactive);
@@ -753,6 +765,7 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
      * Erase all persisted data and destroy the endpoint.
      */
     async delete() {
+        this.lifecycle.change(EndpointLifecycle.Change.Destroying);
         await this.erase();
         await this.close();
     }
@@ -901,6 +914,10 @@ export class Endpoint<T extends EndpointType = EndpointType.Empty> {
         ];
     }
 
+    get [Lifetime.owner](): Lifetime.Owner | undefined {
+        return this.#owner?.construction;
+    }
+
     /**
      * Diagnostic information regarding endpoint state.
      */

package/src/endpoint/properties/Behaviors.ts

@@ -260,7 +260,10 @@ export class Behaviors {
         const activity = this.#endpoint.env.get(NodeActivity);
 
         // Perform initialization
-        let promise = LocalActorContext.act(`initialize<${this.#endpoint}>`, initializeBehaviors, { activity });
+        let promise = LocalActorContext.act(`initialize<${this.#endpoint}>`, initializeBehaviors, {
+            activity,
+            lifetime: this.#endpoint.construction,
+        });
 
         // Once behaviors are ready the endpoint we consider the endpoint "ready"
         const onReady = () => {
@@ -443,10 +446,12 @@ export class Behaviors {
             `close<${this.#endpoint}>`,
             dispose,
 
-            // Note - do not close in an activity because this can cause deadlock
-            //, {
-            //    activity: this.#endpoint.env.get(NodeActivity),
-            //},
+            {
+                lifetime: this.#endpoint.construction,
+
+                // Note - do not close in an activity because this can cause deadlock
+                // activity: this.#endpoint.env.get(NodeActivity),
+            },
         );
     }
 
@@ -649,7 +654,7 @@ export class Behaviors {
                 const backing = this.#backingFor(type);
                 return backing.construction.ready;
             },
-            { activity: this.#endpoint.env.get(NodeActivity) },
+            { activity: this.#endpoint.env.get(NodeActivity), lifetime: this.#endpoint.construction },
         );
 
         if (MaybePromise.is(result)) {

package/src/endpoint/properties/Commands.ts

@@ -58,7 +58,7 @@ function Implementation(endpoint: Endpoint, type: Behavior.Type, name: string):
             }
 
             // Invoke with a dedicated context
-            const context2 = LocalActorContext.open(`invoke-${name}`);
+            const context2 = LocalActorContext.open(`invoke-${name}`, { lifetime: endpoint.construction });
             try {
                 return Promise.resolve(context2.resolve(invokerFor(context2)(input, context)));
             } catch (e) {

package/src/endpoint/properties/EndpointLifecycle.ts

@@ -171,6 +171,10 @@ export class EndpointLifecycle {
                 this.#isInstalled = true;
                 break;
 
+            case EndpointLifecycle.Change.Destroying:
+                this.#isReady = false;
+                break;
+
             case EndpointLifecycle.Change.Ready:
                 // Sanity checks
                 if (!this.#hasId) {

package/src/node/ClientNode.ts

@@ -12,6 +12,7 @@ import { NetworkRuntime } from "#behavior/system/network/NetworkRuntime.js";
 import { Agent } from "#endpoint/Agent.js";
 import { ClientNodeEndpoints } from "#endpoint/properties/ClientNodeEndpoints.js";
 import { EndpointInitializer } from "#endpoint/properties/EndpointInitializer.js";
+import { EndpointLifecycle } from "#endpoint/properties/EndpointLifecycle.js";
 import { EndpointType } from "#endpoint/type/EndpointType.js";
 import { MutableEndpoint } from "#endpoint/type/MutableEndpoint.js";
 import { Diagnostic, Identity, Lifecycle, Logger, MaybePromise } from "#general";
@@ -115,6 +116,8 @@ export class ClientNode extends Node<ClientNode.RootEndpoint> {
      * If you can not reach the device, use {@link delete} instead.
      */
     async decommission() {
+        this.lifecycle.change(EndpointLifecycle.Change.Destroying);
+
         if (this.lifecycle.isCommissioned) {
             this.statusUpdate("decommissioning");
 

package/src/node/Node.ts

@@ -17,12 +17,12 @@ import { MutableEndpoint } from "#endpoint/type/MutableEndpoint.js";
 import {
     Construction,
     Diagnostic,
+    DiagnosticPresentation,
     DiagnosticSource,
     Environment,
     Identity,
     ImplementationError,
     Logger,
-    RuntimeService,
 } from "#general";
 import { Interactable } from "#protocol";
 import type { EndpointNumber } from "#types";
@@ -218,7 +218,7 @@ export abstract class Node<T extends Node.CommonRootEndpoint = Node.CommonRootEn
 
     protected abstract prepareRuntimeShutdown(): Promise<void>;
 
-    get [RuntimeService.label]() {
+    get [DiagnosticPresentation.name]() {
         return ["Runtime for", Diagnostic.strong(this.toString())];
     }
 
@@ -247,6 +247,7 @@ export abstract class Node<T extends Node.CommonRootEndpoint = Node.CommonRootEn
         await this.cancelWithMutex();
         await super[Construction.destruct]();
         DiagnosticSource.delete(this);
+        this.#environment[Symbol.dispose]();
     }
 }
 

package/src/node/ServerNode.ts

@@ -121,6 +121,7 @@ export class ServerNode<T extends ServerNode.RootEndpoint = ServerNode.RootEndpo
      * Perform a factory reset of the node.
      */
     override async erase() {
+        using _erasing = this.construction.join("erasing");
         await this.lifecycle.mutex.produce(this.eraseWithMutex.bind(this));
     }
 

package/src/node/client/ClientCommandMethod.ts

@@ -17,47 +17,40 @@ export function ClientCommandMethod(name: string) {
     // This is our usual hack to give a function a proper name in stack traces
     const temp = {
         // The actual implementation
-        [name](this: ClusterBehavior, fields?: {}) {
-            return invokeOnPeer(this, name, fields);
-        },
-    };
-
-    return temp[name];
-}
-
-/**
- * Invokes a command remotely on behalf of client behaviors.
- */
-async function invokeOnPeer(behavior: ClusterBehavior, command: string, fields?: {}) {
-    const node = behavior.env.get(Node) as ClientNode;
+        async [name](this: ClusterBehavior, fields?: {}) {
+            const node = this.env.get(Node) as ClientNode;
 
-    // TODO when implementing TCP add needed logic for Large messages
-    const chunks = (node.interaction as ClientInteraction).invoke(
-        Invoke({
-            commands: [
-                Invoke.ConcreteCommandRequest<any>({
-                    endpoint: behavior.endpoint,
-                    cluster: behavior.cluster,
-                    command,
-                    fields,
+            // TODO when implementing TCP add needed logic for Large messages
+            const chunks = (node.interaction as ClientInteraction).invoke(
+                Invoke({
+                    commands: [
+                        Invoke.ConcreteCommandRequest<any>({
+                            endpoint: this.endpoint,
+                            cluster: this.cluster,
+                            command: name,
+                            fields,
+                        }),
+                    ],
                 }),
-            ],
-        }),
-    );
+            );
 
-    for await (const chunk of chunks) {
-        for (const entry of chunk) {
-            // We send only one command, so we only get one response back
-            switch (entry.kind) {
-                case "cmd-status":
-                    if (entry.status !== Status.Success) {
-                        throw StatusResponseError.create(entry.status, undefined, entry.clusterStatus);
-                    }
-                    return;
+            for await (const chunk of chunks) {
+                for (const entry of chunk) {
+                    // We send only one command, so we only get one response back
+                    switch (entry.kind) {
+                        case "cmd-status":
+                            if (entry.status !== Status.Success) {
+                                throw StatusResponseError.create(entry.status, undefined, entry.clusterStatus);
+                            }
+                            return;
 
-                case "cmd-response":
-                    return entry.data;
+                        case "cmd-response":
+                            return entry.data;
+                    }
+                }
             }
-        }
-    }
+        },
+    };
+
+    return temp[name];
 }

package/src/node/client/NodePeerAddressStore.ts

@@ -8,7 +8,7 @@ import { RemoteDescriptor } from "#behavior/system/commissioning/RemoteDescripto
 import type { ClientNode } from "#node/ClientNode.js";
 import { IdentityService } from "#node/server/IdentityService.js";
 import type { ServerNode } from "#node/ServerNode.js";
-import { OperationalPeer, PeerAddress, PeerAddressMap, PeerAddressStore } from "#protocol";
+import { PeerAddress, PeerAddressMap, PeerAddressStore, PeerDescriptor } from "#protocol";
 import { FabricIndex, NodeId } from "#types";
 import { Crypto, ServerAddress, ServerAddressUdp } from "@matter/general";
 
@@ -50,7 +50,7 @@ export class NodePeerAddressStore extends PeerAddressStore {
         return address;
     }
 
-    loadPeers(): OperationalPeer[] {
+    loadPeers(): PeerDescriptor[] {
         this.#assignedAddresses = new PeerAddressMap();
         return [...this.#owner.peers]
             .map(node => {
@@ -72,7 +72,7 @@ export class NodePeerAddressStore extends PeerAddressStore {
             .filter(addr => addr !== undefined);
     }
 
-    async updatePeer(peer: OperationalPeer) {
+    async updatePeer(peer: PeerDescriptor) {
         const node = this.#owner.peers.get(peer.address);
         if (!node) {
             return;

package/src/node/client/Peers.ts

@@ -33,7 +33,7 @@ import {
 } from "#general";
 import { ClientGroup } from "#node/ClientGroup.js";
 import { InteractionServer } from "#node/server/InteractionServer.js";
-import { ClientSubscriptionHandler, ClientSubscriptions, FabricManager, PeerAddress } from "#protocol";
+import { ClientSubscriptionHandler, ClientSubscriptions, FabricManager, PeerAddress, PeerSet } from "#protocol";
 import { ServerNodeStore } from "#storage/server/ServerNodeStore.js";
 import { FabricIndex } from "@matter/types";
 import { ClientNode } from "../ClientNode.js";
@@ -351,12 +351,30 @@ export class Peers extends EndpointContainer<ClientNode> {
             return;
         }
 
+        setPeerLimits();
+
         node.eventsOf(type).leave?.on(({ fabricIndex }) => this.#onLeave(node, fabricIndex));
         node.eventsOf(type).shutDown?.on(() => this.#onShutdown(node));
+        node.eventsOf(type).capabilityMinima$Changed.on(setPeerLimits);
+
+        function setPeerLimits() {
+            const peerAddress = node.maybeStateOf(CommissioningClient)?.peerAddress;
+            if (peerAddress) {
+                node.env.get(PeerSet).for(peerAddress).limits = node.stateOf(type).capabilityMinima;
+            }
+        }
     }
 
     #onLeave(node: ClientNode, fabricIndex: FabricIndex) {
+        if (!node.lifecycle.isReady) {
+            return;
+        }
+
         this.#mutex.run(async () => {
+            if (!node.lifecycle.isReady) {
+                return;
+            }
+
             const { fabrics: peerFabrics } = node.maybeStateOf(OperationalCredentialsClient) ?? {};
             const peerFabric = peerFabrics?.find(fabric => fabric.fabricIndex === fabricIndex);
             if (!peerFabric) {

package/src/node/integration/ProtocolService.ts

@@ -39,6 +39,7 @@ import {
     EventTypeProtocol,
     FabricManager,
     hasRemoteActor,
+    Mark,
     OccurrenceManager,
     toWildcardOrHexPath,
     Val,
@@ -148,7 +149,7 @@ class NodeState {
                 if (!fabrics) {
                     fabrics = node.env.get(FabricManager);
                 }
-                return fabrics.findByIndex(index)?.nodeId;
+                return fabrics.maybeForIndex(index)?.nodeId;
             },
 
             get eventHandler() {
@@ -562,7 +563,8 @@ function invokeCommand(
     const context = session as ActionContext;
 
     logger.info(
-        "Invoke «",
+        "Invoke",
+        Mark.INBOUND,
         Diagnostic.strong(`${path.toString()}.${command.name}`),
         session.transaction.via,
         requestDiagnostic,