@matter/protocol 0.16.0-alpha.0-20251217-038f88085 → 0.16.0-alpha.0-20251221-21acf226d

package/src/peer/ControllerCommissioningFlow.ts

@@ -8,12 +8,14 @@ import { ClientInteraction } from "#action/client/ClientInteraction.js";
 import { ClientRead } from "#action/client/ClientRead.js";
 import { Invoke } from "#action/request/Invoke.js";
 import { Read } from "#action/request/Read.js";
+import { Write } from "#action/request/Write.js";
 import { Certificate } from "#certificate/kinds/Certificate.js";
 import { BasicInformation } from "#clusters/basic-information";
 import { Descriptor } from "#clusters/descriptor";
 import { GeneralCommissioning } from "#clusters/general-commissioning";
 import { NetworkCommissioning } from "#clusters/network-commissioning";
 import { OperationalCredentials } from "#clusters/operational-credentials";
+import { OtaSoftwareUpdateRequestor } from "#clusters/ota-software-update-requestor";
 import { TimeSynchronizationCluster } from "#clusters/time-synchronization";
 import {
     Bytes,
@@ -23,11 +25,11 @@ import {
     ImplementationError,
     Instant,
     Logger,
-    Millis,
     Minutes,
     repackErrorAs,
     Seconds,
     Time,
+    Timer,
     Timespan,
     Timestamp,
     UnexpectedDataError,
@@ -37,6 +39,7 @@ import {
     ClusterType,
     EndpointNumber,
     FabricIndex,
+    NodeId,
     Status,
     StatusResponseError,
     TypeFromPartialBitSchema,
@@ -52,6 +55,11 @@ import { PeerAddress } from "./PeerAddress.js";
 
 const logger = Logger.get("ControllerCommissioner");
 
+export interface OtaProviderLocation {
+    nodeId: NodeId;
+    endpoint: EndpointNumber;
+}
+
 /**
  * User specific options for the Commissioning process
  */
@@ -86,6 +94,9 @@ export type ControllerCommissioningFlowOptions = {
         networkName: string;
         operationalDataset: string;
     };
+
+    /** The Location of the OTA provider for this fabric set on the commissioned devices if OTA is supported */
+    otaUpdateProviderLocation?: OtaProviderLocation;
 };
 
 /** Types representation of a general commissioning response. */
@@ -137,10 +148,14 @@ type CollectedCommissioningData = {
     basicCommissioningInfo?: TypeFromSchema<typeof GeneralCommissioning.TlvBasicCommissioningInfo>;
     productName?: string;
     networkFeatures?: {
-        endpointId: number;
+        endpointId: EndpointNumber;
         value: TypeFromPartialBitSchema<typeof NetworkCommissioning.Complete.features>;
     }[];
-    networkStatus?: { endpointId: number; value: TypeFromSchema<typeof NetworkCommissioning.TlvNetworkInfo>[] }[];
+    networkStatus?: {
+        endpointId: EndpointNumber;
+        value: TypeFromSchema<typeof NetworkCommissioning.TlvNetworkInfo>[];
+    }[];
+    otaRequestorList?: EndpointNumber[];
     rootPartsList?: EndpointNumber[];
     rootServerList?: ClusterId[];
     vendorId?: VendorId;
@@ -182,6 +197,9 @@ class RecoverableCommissioningError extends CommissioningError {}
 
 const DEFAULT_FAILSAFE_TIME = Minutes.one;
 
+/** When we execute longer actions like network connections or reconnection, we need to keep the BTP session alive */
+const BTP_IDLE_ALIVE_INTERVAL = Seconds(25);
+
 const RootEndpointNumber = EndpointNumber(0);
 
 /**
@@ -205,6 +223,7 @@ export class ControllerCommissioningFlow {
     protected lastBreadcrumb = 1;
     protected collectedCommissioningData: CollectedCommissioningData = {};
     #defaultFailSafeTime = DEFAULT_FAILSAFE_TIME;
+    #armFailsafeInterval?: Timer;
 
     constructor(
         /** ClientInteraction for the initiated PASE session */
@@ -247,7 +266,11 @@ export class ControllerCommissioningFlow {
         for (const step of this.commissioningSteps) {
             logger.info(`Executing commissioning step ${step.stepNumber}.${step.subStepNumber}: ${step.name}`);
             try {
-                if (step.reArmFailsafe && !failSafeTimerReArmedAfterPreviousStep) {
+                if (
+                    step.reArmFailsafe &&
+                    !failSafeTimerReArmedAfterPreviousStep &&
+                    !this.#armFailsafeInterval?.isRunning
+                ) {
                     logger.debug(`Re-Arming failsafe timer before executing step`);
                     await this.#armFailsafe();
                 }
@@ -269,7 +292,7 @@ export class ControllerCommissioningFlow {
 
                     /**
                      * Commissioner SHALL re-arm the Fail-safe timer on the Commissionee to the desired commissioning
-                     * timeout within 60 seconds of the completion of PASE session establishment, using the ArmFailSafe
+                     * timeout within 60 seconds of the completion of a PASE session establishment, using the ArmFailSafe
                      * command (see Section 11.9.6.2, “ArmFailSafe Command”)
                      */
                     const timeLeft = Timespan(Time.nowMs, this.#currentFailSafeEndTime).duration;
@@ -277,7 +300,7 @@ export class ControllerCommissioningFlow {
                         logger.info(
                             `After Commissioning step ${step.stepNumber}.${step.subStepNumber}: ${
                                 step.name
-                            } succeeded, ${timeLeft}s left for failsafe timer, re-arming failsafe`,
+                            } succeeded, ${Duration.format(timeLeft)} left for failsafe timer, re-arming failsafe`,
                         );
                         await this.#armFailsafe();
                         failSafeTimerReArmedAfterPreviousStep = true;
@@ -496,11 +519,20 @@ export class ControllerCommissioningFlow {
         });
 
         this.commissioningSteps.push({
-            stepNumber: 99, // Should be allowed in Step 13, but Tasmota is not supporting this
+            stepNumber: 98, // Should be allowed in Step 13, but Tasmota is not supporting this
             subStepNumber: 1,
             name: "OperationalCredentials.UpdateFabricLabel",
             stepLogic: () => this.#updateFabricLabel(),
         });
+
+        if (this.commissioningOptions.otaUpdateProviderLocation !== undefined) {
+            this.commissioningSteps.push({
+                stepNumber: 99,
+                subStepNumber: 1,
+                name: "AdditionalLogic.AddDefaultOtaProvider",
+                stepLogic: () => this.#addDefaultOtaProvider(),
+            });
+        }
     }
 
     #sortSteps() {
@@ -621,16 +653,22 @@ export class ControllerCommissioningFlow {
                     cluster: NetworkCommissioning.Complete,
                     attributes: ["featureMap", "networks"],
                 }),
+                Read.Attribute({
+                    cluster: OtaSoftwareUpdateRequestor.Complete,
+                    attributes: ["defaultOtaProviders"],
+                }),
             ),
         );
+
         const networkFeatures = new Array<{
-            endpointId: number;
+            endpointId: EndpointNumber;
             value: TypeFromPartialBitSchema<typeof NetworkCommissioning.Complete.features>;
         }>();
         const networkStatus = new Array<{
-            endpointId: number;
+            endpointId: EndpointNumber;
             value: TypeFromSchema<typeof NetworkCommissioning.TlvNetworkInfo>[];
         }>();
+        const otaRequestors = new Array<EndpointNumber>();
 
         for await (const data of networkData) {
             for (const entry of data) {
@@ -641,22 +679,29 @@ export class ControllerCommissioningFlow {
                     path: { endpointId, attributeId },
                     value,
                 } = entry;
-                if (attributeId === NetworkCommissioning.Complete.attributes.featureMap.id) {
-                    networkFeatures.push({
-                        endpointId,
-                        value: value as TypeFromPartialBitSchema<typeof NetworkCommissioning.Complete.features>,
-                    });
-                } else if (attributeId === NetworkCommissioning.Complete.attributes.networks.id) {
-                    networkStatus.push({
-                        endpointId,
-                        value: value as TypeFromSchema<typeof NetworkCommissioning.TlvNetworkInfo>[],
-                    });
+                switch (attributeId) {
+                    case NetworkCommissioning.Complete.attributes.featureMap.id:
+                        networkFeatures.push({
+                            endpointId,
+                            value: value as TypeFromPartialBitSchema<typeof NetworkCommissioning.Complete.features>,
+                        });
+                        break;
+                    case NetworkCommissioning.Complete.attributes.networks.id:
+                        networkStatus.push({
+                            endpointId,
+                            value: value as TypeFromSchema<typeof NetworkCommissioning.TlvNetworkInfo>[],
+                        });
+                        break;
+                    case OtaSoftwareUpdateRequestor.Complete.attributes.defaultOtaProviders.id:
+                        otaRequestors.push(endpointId);
+                        break;
                 }
             }
         }
 
         this.collectedCommissioningData.networkFeatures = networkFeatures;
         this.collectedCommissioningData.networkStatus = networkStatus;
+        this.collectedCommissioningData.otaRequestorList = otaRequestors;
 
         return {
             code: CommissioningStepResultCode.Success,
@@ -667,11 +712,11 @@ export class ControllerCommissioningFlow {
     /**
      * Step 7
      * Commissioner SHALL re-arm the Fail-safe timer on the Commissionee to the desired commissioning
-     * timeout within 60 seconds of the completion of PASE session establishment, using the
+     * timeout within 60 seconds of the completion of a PASE session establishment, using the
      * ArmFailSafe command (see Section 11.10.6.2, “ArmFailSafe Command”). A Commissioner MAY
-     * obtain device information including guidance on the fail-safe value from the Commissionee by
+     * collect device information including guidance on the fail-safe value from the Commissionee by
      * reading BasicCommissioningInfo attribute (see Section 11.10.5.2, “BasicCommissioningInfo
-     * Attribute”) prior to invoking the ArmFailSafe command.
+     * Attribute”) before invoking the ArmFailSafe command.
      */
     async #armFailsafe(time?: Duration) {
         if (this.collectedCommissioningData.basicCommissioningInfo === undefined) {
@@ -722,12 +767,39 @@ export class ControllerCommissioningFlow {
     async #ensureFailsafeTimerFor(maxProcessingTime: Duration) {
         const minFailsafeTime = this.interaction.maximumPeerResponseTime(maxProcessingTime);
 
+        if (this.interaction.channelType === ChannelType.BLE) {
+            this.#armFailsafeInterval?.stop();
+
+            this.#armFailsafeInterval = Time.getPeriodicTimer(
+                "Re-Arm Failsafe during longer interactions",
+                BTP_IDLE_ALIVE_INTERVAL,
+                () => {
+                    const now = Time.nowMs;
+                    if (this.#commissioningExpiryTime !== undefined && now < this.#commissioningExpiryTime) {
+                        logger.debug(
+                            `Re-Arm Failsafe Timer during longer actions with device. Time left: ${Duration.format(Timespan(now, this.#commissioningExpiryTime).duration)}`,
+                        );
+                        this.#armFailsafe().catch(error => {
+                            logger.info("Error while re-arming failsafe during reconnect", error);
+                            this.#armFailsafeInterval?.stop();
+                        });
+                    } else {
+                        // Stop as soon as we are over the maximum commissioning time
+                        this.#armFailsafeInterval?.stop();
+                    }
+                },
+            ).start();
+        }
+
+        // When not on BLE, we just ensure the Failsafe timer is armed long enough
         const timeLeft = this.#failSafeTimeLeft;
         if (timeLeft < minFailsafeTime) {
-            logger.debug(`Failsafe timer has only ${timeLeft}s left, re-arming for at least ${minFailsafeTime}`);
+            logger.debug(
+                `Failsafe timer has only ${Duration.format(timeLeft)} left, re-arming for at least ${Duration.format(minFailsafeTime)}`,
+            );
             await this.#armFailsafe(Duration.max(minFailsafeTime, this.#defaultFailSafeTime));
         } else {
-            logger.debug(`Failsafe timer is already set for at least ${Seconds.of(timeLeft)}s`);
+            logger.debug(`Failsafe timer is already set for at least ${Duration.format(timeLeft)}`);
         }
     }
 
@@ -1189,7 +1261,6 @@ export class ControllerCommissioningFlow {
 
         // Only Scan when the device supports concurrent connections
         if (this.collectedCommissioningData.supportsConcurrentConnection !== false) {
-            // TODO add message transmission time
             await this.#ensureFailsafeTimerFor(Seconds(scanMaxTimeSeconds));
 
             const { networkingStatus, wiFiScanResults, debugText } = await this.#invokeCommand(
@@ -1273,7 +1344,6 @@ export class ControllerCommissioningFlow {
             };
         }
 
-        // TODO Add retransmission time
         await this.#ensureFailsafeTimerFor(Seconds(connectMaxTimeSeconds));
 
         const connectResult = await this.#invokeCommand(
@@ -1282,7 +1352,7 @@ export class ControllerCommissioningFlow {
                 cluster: NetworkCommissioning.Complete,
                 command: "connectNetwork",
                 fields: {
-                    networkId: networkId,
+                    networkId,
                     breadcrumb: this.lastBreadcrumb++,
                 },
             },
@@ -1440,7 +1510,7 @@ export class ControllerCommissioningFlow {
             `Commissionee added Thread network ${this.commissioningOptions.threadNetwork.networkName} with network index ${networkIndex}`,
         );
 
-        const updatedNetworks = await this.#readConcreteAttributeValues(
+        const [updatedNetworks] = await this.#readConcreteAttributeValues(
             Read(
                 Read.Attribute({
                     endpoint: RootEndpointNumber,
@@ -1474,7 +1544,7 @@ export class ControllerCommissioningFlow {
                 cluster: NetworkCommissioning.Complete,
                 command: "connectNetwork",
                 fields: {
-                    networkId: networkId,
+                    networkId,
                     breadcrumb: this.lastBreadcrumb++,
                 },
             },
@@ -1513,31 +1583,12 @@ export class ControllerCommissioningFlow {
 
         logger.debug(`Reconnecting with device with ${isConcurrentFlow ? "concurrent" : "non-concurrent"} flow ...`);
 
-        // Reconnection with discovery could take longer then the default failsafe time, so we need to
+        // Reconnection with discovery could take longer than the default failsafe time, so we need to
         // re-arm the failsafe when we are in a concurrent commissioning flow also in parallel to
         // the operative reconnection
-        // TODO: Check whats needed for non-concurrent commissioning flows (maybe arm initially longer?)
-        const reArmFailsafeInterval = Time.getPeriodicTimer(
-            "Re-Arm Failsafe during reconnect",
-            Millis(this.#defaultFailSafeTime / 2),
-            () => {
-                const now = Time.nowMs;
-                if (this.#commissioningExpiryTime !== undefined && now < this.#commissioningExpiryTime) {
-                    logger.error(
-                        `Re-Arm Failsafe Timer during reconnect with device. Time left: ${Math.round((this.#commissioningExpiryTime - now) / 1000)}s`,
-                    );
-                    this.#armFailsafe().catch(error => {
-                        logger.error("Error while re-arming failsafe during reconnect", error);
-                        reArmFailsafeInterval.stop();
-                    });
-                } else {
-                    // Stop as soon as we are over the maximum commissioning time
-                    reArmFailsafeInterval.stop();
-                }
-            },
-        );
-        if (isConcurrentFlow) {
-            reArmFailsafeInterval.start();
+        await this.#ensureFailsafeTimerFor(Seconds(120));
+        if (!isConcurrentFlow) {
+            this.#armFailsafeInterval?.stop();
         }
 
         let transitionResult: ClientInteraction | undefined;
@@ -1549,10 +1600,10 @@ export class ControllerCommissioningFlow {
             );
         } catch (cause) {
             throw new OperativeConnectionFailedError("Operative reconnection with device failed", { cause });
+        } finally {
+            this.#armFailsafeInterval?.stop();
         }
 
-        reArmFailsafeInterval.stop();
-
         if (transitionResult === undefined) {
             logger.debug("CASE commissioning handled externally, terminating commissioning flow");
             return {
@@ -1600,4 +1651,60 @@ export class ControllerCommissioningFlow {
             breadcrumb: this.lastBreadcrumb,
         };
     }
+
+    async #addDefaultOtaProvider() {
+        if (this.commissioningOptions.otaUpdateProviderLocation === undefined) {
+            return {
+                code: CommissioningStepResultCode.Skipped,
+                breadcrumb: this.lastBreadcrumb,
+            };
+        }
+
+        if (!this.collectedCommissioningData?.otaRequestorList?.length) {
+            logger.debug("No OTA Requestor found, skipping adding default OTA provider");
+            return {
+                code: CommissioningStepResultCode.Skipped,
+                breadcrumb: this.lastBreadcrumb,
+            };
+        }
+
+        const { nodeId: providerNodeId, endpoint } = this.commissioningOptions.otaUpdateProviderLocation;
+
+        let success = false;
+        for (const requestorEndpoint of this.collectedCommissioningData.otaRequestorList) {
+            try {
+                // Fabric scoped attribute, so we just overwrite our value
+                await this.interaction.write(
+                    Write(
+                        Write.Attribute({
+                            endpoint: requestorEndpoint,
+                            cluster: OtaSoftwareUpdateRequestor.Complete,
+                            attributes: ["defaultOtaProviders"],
+                            value: [
+                                {
+                                    providerNodeId,
+                                    endpoint,
+                                    fabricIndex: this.fabric.fabricIndex,
+                                },
+                            ],
+                        }),
+                    ),
+                );
+                success = true;
+                logger.debug(`Added default OTA provider on endpoint ${endpoint}`);
+            } catch (error) {
+                // Ok to just log, we will check again also in the SoftwareUpdateManager
+                logger.info("Could not set default OTA provider", error);
+            }
+        }
+
+        return {
+            code: success ? CommissioningStepResultCode.Success : CommissioningStepResultCode.Failure,
+            breadcrumb: this.lastBreadcrumb,
+        };
+    }
+
+    close() {
+        this.#armFailsafeInterval?.stop();
+    }
 }

package/src/peer/PeerSet.ts

@@ -42,6 +42,7 @@ import { CaseClient } from "#session/case/CaseClient.js";
 import { SecureSession } from "#session/SecureSession.js";
 import { Session } from "#session/Session.js";
 import { SessionManager } from "#session/SessionManager.js";
+import { SessionParameters } from "#session/SessionParameters.js";
 import { CaseAuthenticatedTag, NodeId, SECURE_CHANNEL_PROTOCOL_ID, SecureChannelStatusCode } from "#types";
 import { ControllerDiscovery, DiscoveryError, PairRetransmissionLimitReachedError } from "./ControllerDiscovery.js";
 import { Peer } from "./Peer.js";
@@ -266,12 +267,12 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
 
         const peer = this.for(address);
 
-        // We have a session, so we assume we have connection
+        // We have a session, so we assume we have a connection
         if (this.#sessions.maybeSessionFor(address)) {
             return;
         }
 
-        // There is an active discovery running for Full discovery, we can not do more than that, do not block the call
+        // There is an active discovery running for Full discovery, we cannot do more than that, do not block the call
         // because it will error in the next step
         if (peer.activeDiscovery?.type === NodeDiscoveryType.FullDiscovery) {
             return;
@@ -600,11 +601,14 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
                     return device !== undefined ? [device] : [];
                 },
                 async (operationalAddress, peer) => {
-                    const result = await this.#pair(address, operationalAddress, peer, { caseAuthenticatedTags });
-                    await this.#addOrUpdatePeer(address, operationalAddress, {
+                    const peerData = {
                         ...discoveryData,
                         ...peer,
+                    };
+                    const result = await this.#pair(address, operationalAddress, peerData, {
+                        caseAuthenticatedTags,
                     });
+                    await this.#addOrUpdatePeer(address, operationalAddress, peerData);
                     return result;
                 },
             );
@@ -684,15 +688,24 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
 
         const operationalChannel = await operationalInterface.openChannel(operationalServerAddress);
         const { sessionParameters } = this.#sessions.findResumptionRecordByAddress(address) ?? {};
+
+        // Build session parameters, only including values that are actually defined
+        // to allow SessionParameters fallbacks to apply correctly
+        const idleInterval = discoveryData?.SII ?? sessionParameters?.idleInterval;
+        const activeInterval = discoveryData?.SAI ?? sessionParameters?.activeInterval;
+        const activeThreshold = discoveryData?.SAT ?? sessionParameters?.activeThreshold;
+
+        const mergedSessionParameters: SessionParameters.Config = {
+            ...sessionParameters,
+            ...(idleInterval !== undefined ? { idleInterval } : {}),
+            ...(activeInterval !== undefined ? { activeInterval } : {}),
+            ...(activeThreshold !== undefined ? { activeThreshold } : {}),
+        };
+
         const unsecuredSession = this.#sessions.createUnsecuredSession({
             channel: operationalChannel,
-            // Use the session parameters from MDNS announcements when available and rest is assumed to be fallbacks
-            sessionParameters: {
-                ...sessionParameters,
-                idleInterval: discoveryData?.SII ?? sessionParameters?.idleInterval,
-                activeInterval: discoveryData?.SAI ?? sessionParameters?.activeInterval,
-                activeThreshold: discoveryData?.SAT ?? sessionParameters?.activeThreshold,
-            },
+            // Use the session parameters from MDNS announcements when available and rest is assumed to be fall back
+            sessionParameters: mergedSessionParameters,
             isInitiator: true,
         });
 
@@ -735,7 +748,7 @@ export class PeerSet implements ImmutableSet<Peer>, ObservableSet<Peer> {
                 // It seems the stored resumption record is outdated; we need to retry pairing without resumption
                 if (await this.#sessions.deleteResumptionRecord(fabric.addressOf(address.nodeId))) {
                     logger.info(
-                        `Case client: Resumption record seems outdated for Fabric ${NodeId.toHexString(fabric.nodeId)} (index ${fabric.fabricIndex}) and PeerNode ${NodeId.toHexString(address.nodeId)}. Retrying pairing without resumption...`,
+                        `Case client: Resumption record seems outdated for Fabric ${NodeId.strOf(fabric.nodeId)} (index ${fabric.fabricIndex}) and PeerNode ${NodeId.strOf(address.nodeId)}. Retrying pairing without resumption...`,
                     );
                     // An endless loop should not happen here, as the resumption record is deleted in the next step
                     return await this.#doCasePair(paseSession, address, options);

package/src/protocol/DeviceAdvertiser.ts

@@ -47,7 +47,7 @@ export class DeviceAdvertiser {
             this.#advertiseFabric(fabric, "startup");
         });
 
-        // When a fabric is updated we might need to adjust announcements
+        // When fabric is updated, we might need to adjust announcements
         this.#observers.on(fabrics.events.replaced, async fabric => {
             if (!this.#isOperational) {
                 return;
@@ -63,7 +63,7 @@ export class DeviceAdvertiser {
                 fabricIndexAdvertisements.every(
                     ad =>
                         ad.isOperational() &&
-                        ad.description.fabric.operationalId === fabric.operationalId &&
+                        ad.description.fabric.globalId === fabric.globalId &&
                         ad.description.fabric.nodeId === fabric.nodeId,
                 )
             ) {
@@ -77,7 +77,7 @@ export class DeviceAdvertiser {
             this.#advertiseFabric(fabric, "startup");
         });
 
-        // When a fabric is deleted, cancel any active advertisement
+        // When fabric is deleted, cancel any active advertisement
         this.#observers.on(fabrics.events.deleting, fabric => {
             Advertisement.cancelAll(this.#advertisements(ad => ad.isOperational() && ad.description.fabric === fabric));
         });
@@ -86,7 +86,7 @@ export class DeviceAdvertiser {
         // configured
         this.#observers.on(sessions.sessions.added, session => {
             const fabricIndex = session.fabric?.fabricIndex;
-            const fabric = fabricIndex ? fabrics.maybeForIndex(fabricIndex) : undefined;
+            const fabric = fabricIndex ? fabrics.maybeFor(fabricIndex) : undefined;
             if (!fabric) {
                 return;
             }
@@ -102,7 +102,7 @@ export class DeviceAdvertiser {
         // When a session is closed, conditionally resume broadcast
         this.#observers.on(sessions.sessions.deleted, session => {
             const fabricIndex = session.fabric?.fabricIndex;
-            const fabric = fabricIndex ? fabrics.maybeForIndex(fabricIndex) : undefined;
+            const fabric = fabricIndex ? fabrics.maybeFor(fabricIndex) : undefined;
 
             // If this was an operational connection, readvertise if we're no longer connected to the peer
             if (fabric) {

package/src/protocol/ExchangeProvider.ts

@@ -36,7 +36,7 @@ export abstract class ExchangeProvider {
     }
 
     abstract maximumPeerResponseTime(expectedProcessingTime?: Duration): Duration;
-    abstract initiateExchange(): Promise<MessageExchange>;
+    abstract initiateExchange(protocol?: number): Promise<MessageExchange>;
     abstract reconnectChannel(options: { asOf?: Timestamp; resetInitialState?: boolean }): Promise<boolean>;
     abstract session: Session;
 
@@ -103,7 +103,7 @@ export class ReconnectableExchangeProvider extends ExchangeProvider {
         return this.#channelUpdated;
     }
 
-    async initiateExchange(): Promise<MessageExchange> {
+    async initiateExchange(protocol = INTERACTION_PROTOCOL_ID): Promise<MessageExchange> {
         if (!this.sessions.maybeSessionFor(this.#address)) {
             using _connecting = this.sessions.construction.join(
                 "connecting to",
@@ -115,7 +115,7 @@ export class ReconnectableExchangeProvider extends ExchangeProvider {
         if (!this.sessions.maybeSessionFor(this.#address)) {
             throw new SessionClosedError("Channel not connected");
         }
-        return this.exchangeManager.initiateExchange(this.#address, INTERACTION_PROTOCOL_ID);
+        return this.exchangeManager.initiateExchange(this.#address, protocol);
     }
 
     async reconnectChannel(options: { asOf?: Timestamp; resetInitialState?: boolean } = {}) {

package/src/protocol/MessageExchange.ts

@@ -187,9 +187,9 @@ export class MessageExchange {
             Diagnostic.dict({
                 protocol: this.#protocolId,
                 peerSess: Session.idStrOf(this.#peerSessionId),
-                SAT: Duration.format(activeThreshold),
-                SAI: Duration.format(activeInterval),
-                SII: Duration.format(idleInterval),
+                SAT: activeThreshold !== undefined ? Duration.format(activeThreshold) : undefined,
+                SAI: activeInterval !== undefined ? Duration.format(activeInterval) : undefined,
+                SII: idleInterval !== undefined ? Duration.format(idleInterval) : undefined,
                 maxTrans: MRP.MAX_TRANSMISSIONS,
                 exchangeFlags: Diagnostic.asFlags({
                     MRP: this.session.usesMrp,

package/src/protocol/ProtocolMocks.ts

@@ -28,7 +28,16 @@ import { MessageType } from "#interaction/InteractionMessenger.js";
 import { NodeSession as RealNodeSession } from "#session/NodeSession.js";
 import { Session } from "#session/Session.js";
 import { SessionParameters } from "#session/SessionParameters.js";
-import { FabricId, FabricIndex, NodeId, SECURE_CHANNEL_PROTOCOL_ID, Status, TlvStatusResponse, VendorId } from "#types";
+import {
+    FabricId,
+    FabricIndex,
+    GlobalFabricId,
+    NodeId,
+    SECURE_CHANNEL_PROTOCOL_ID,
+    Status,
+    TlvStatusResponse,
+    VendorId,
+} from "#types";
 import { Specification } from "@matter/model";
 import { MessageChannel as RealMessageChannel } from "./MessageChannel.js";
 import { MessageExchange, MessageExchangeContext } from "./MessageExchange.js";
@@ -38,7 +47,7 @@ export namespace ProtocolMocks {
      * A fabric that will fill any fields not provided with placeholder values.
      */
     export class Fabric extends RealFabric {
-        constructor(config?: Partial<RealFabric.Config>, crypto?: Crypto) {
+        constructor(config?: Partial<RealFabric.SyncConfig>, crypto?: Crypto) {
             if (!crypto) {
                 crypto = Environment.default.maybeGet(Crypto);
                 if (!(crypto instanceof MockCrypto)) {
@@ -60,7 +69,7 @@ export namespace ProtocolMocks {
     }
 
     export namespace Fabric {
-        export const defaults: RealFabric.Config = {
+        export const defaults: RealFabric.SyncConfig = {
             fabricId: FabricId(0x2906c908d115d362n),
             fabricIndex: FabricIndex(1),
             identityProtectionKey: Bytes.empty,
@@ -69,7 +78,7 @@ export namespace ProtocolMocks {
             label: "test-fabric",
             nodeId: NodeId(0xcd5544aa7b13ef14n),
             operationalCert: Bytes.empty,
-            operationalId: Bytes.empty,
+            globalId: GlobalFabricId(0),
             operationalIdentityProtectionKey: b$`9bc61cd9c62a2df6d64dfcaa9dc472d4`,
             rootCert: Bytes.empty,
             rootNodeId: NodeId(1),

package/src/session/NodeSession.ts

@@ -28,7 +28,7 @@ import { MessageCounter } from "#protocol/MessageCounter.js";
 import { MessageExchange } from "#protocol/MessageExchange.js";
 import { MessageReceptionStateEncryptedWithoutRollover } from "#protocol/MessageReceptionState.js";
 import { SecureChannelMessenger } from "#securechannel/SecureChannelMessenger.js";
-import { CaseAuthenticatedTag, FabricIndex, NodeId } from "#types";
+import { CaseAuthenticatedTag, FabricIndex, GlobalFabricId, NodeId } from "#types";
 import { SecureSession } from "./SecureSession.js";
 import { Session } from "./Session.js";
 import { SessionParameters } from "./SessionParameters.js";
@@ -321,7 +321,7 @@ export class NodeSession extends SecureSession {
         super.addExchange(exchange);
         exchange.closed.on(async () => {
             this.exchanges.delete(exchange);
-            if (this.deferredClose && !this.exchanges.size) {
+            if (this.deferredClose && !this.hasActiveExchanges) {
                 this.deferredClose = false;
                 await this.close();
             }
@@ -391,7 +391,7 @@ export namespace NodeSession {
             Diagnostic.strong(PeerAddress({ fabricIndex: fabric.fabricIndex, nodeId: peerNodeId }).toString()),
             Diagnostic.dict({
                 address: messenger.channelName,
-                fabric: `${NodeId.toHexString(fabric.nodeId)} (#${fabric.fabricIndex})`,
+                fabric: `${GlobalFabricId.strOf(fabric.globalId)} (#${fabric.fabricIndex})`,
                 ...session.parameterDiagnostics,
             }),
         );

package/src/session/Session.ts

@@ -268,6 +268,7 @@ export abstract class Session {
             }
             for (const exchange of this.#exchanges) {
                 if (exchange === except) {
+                    this.deferredClose = true;
                     continue;
                 }
                 await exchange.close(true);