@matter/protocol 0.16.0-alpha.0-20250930-05e6cc3f8 → 0.16.0-alpha.0-20251003-dc6d5523d

package/src/interaction/SubscriptionClient.ts

@@ -5,10 +5,11 @@
  */
 
 import { Duration, Environment, Environmental, Logger, MaybePromise, Millis, Time, Timer } from "#general";
+import { DecodedDataReport } from "#interaction/DecodedDataReport.js";
 import { MessageExchange } from "#protocol/MessageExchange.js";
 import { ProtocolHandler } from "#protocol/ProtocolHandler.js";
 import { INTERACTION_PROTOCOL_ID } from "#types";
-import { DataReport, IncomingInteractionClientMessenger } from "./InteractionMessenger.js";
+import { IncomingInteractionClientMessenger } from "./InteractionMessenger.js";
 
 const logger = Logger.get("SubscriptionClient");
 
@@ -16,7 +17,7 @@ export interface RegisteredSubscription {
     id: number;
     maximumPeerResponseTime: Duration;
     maxInterval: Duration;
-    onData: (dataReport: DataReport) => MaybePromise<void>;
+    onData: (dataReport: DecodedDataReport) => MaybePromise<void>;
     onTimeout?: () => void;
 }
 
@@ -28,7 +29,7 @@ export interface RegisteredSubscription {
 export class SubscriptionClient implements ProtocolHandler {
     readonly id = INTERACTION_PROTOCOL_ID;
     readonly requiresSecureSession = true;
-    readonly #listeners = new Map<number, (dataReport: DataReport) => MaybePromise<void>>();
+    readonly #listeners = new Map<number, (dataReport: DecodedDataReport) => MaybePromise<void>>();
     readonly #timeouts = new Map<number, Timer>();
 
     constructor() {}
@@ -80,10 +81,10 @@ export class SubscriptionClient implements ProtocolHandler {
     async onNewExchange(exchange: MessageExchange) {
         const messenger = new IncomingInteractionClientMessenger(exchange);
 
-        let dataReport: DataReport;
+        let dataReport: DecodedDataReport;
         try {
             // TODO Adjust this to getting packages as callback when received to handle error cases and checks outside
-            dataReport = await messenger.readAggregateDataReport([...this.#listeners.keys()]);
+            dataReport = await messenger.readAggregateDataReport(undefined, [...this.#listeners.keys()]);
         } finally {
             messenger.close().catch(error => logger.info("Error closing client messenger", error));
         }

package/src/mdns/MdnsClient.ts

@@ -26,7 +26,7 @@ import {
     ObserverGroup,
     Seconds,
     ServerAddress,
-    ServerAddressIp,
+    ServerAddressUdp,
     SrvRecordValue,
     Time,
     Timer,
@@ -60,7 +60,7 @@ const logger = Logger.get("MdnsClient");
 
 const MDNS_EXPIRY_GRACE_PERIOD_FACTOR = 1.05;
 
-type MatterServerRecordWithExpire = ServerAddressIp & Lifespan;
+type MatterServerRecordWithExpire = ServerAddressUdp & Lifespan;
 
 /** Type for commissionable Device records including Lifespan details. */
 type CommissionableDeviceRecordWithExpire = Omit<CommissionableDevice, "addresses"> &
@@ -354,7 +354,7 @@ export class MdnsClient implements Scanner {
                 ip,
                 port,
                 type: "udp",
-            })) as ServerAddressIp[],
+            })) as ServerAddressUdp[],
         };
     }
 
@@ -570,7 +570,7 @@ export class MdnsClient implements Scanner {
                         ip,
                         port,
                         type: "udp",
-                    })) as ServerAddressIp[],
+                    })) as ServerAddressUdp[],
                     discoveredAt: undefined,
                     ttl: undefined,
                 };

package/src/peer/ControllerCommissioner.ts

@@ -13,15 +13,16 @@ import {
     Channel,
     ChannelType,
     ClassExtends,
+    ConnectionlessTransportSet,
     Diagnostic,
     Duration,
     Environment,
     Environmental,
+    ImplementationError,
     isIPv6,
     Logger,
     Millis,
     Minutes,
-    NetInterfaceSet,
     NoResponseTimeoutError,
     Seconds,
     ServerAddress,
@@ -129,7 +130,7 @@ export interface ControllerCommissionerContext {
     peers: PeerSet;
     clients: InteractionClientProvider;
     scanners: ScannerSet;
-    netInterfaces: NetInterfaceSet;
+    transports: ConnectionlessTransportSet;
     sessions: SessionManager;
     exchanges: ExchangeManager;
     ca: CertificateAuthority;
@@ -152,7 +153,7 @@ export class ControllerCommissioner {
             peers: env.get(PeerSet),
             clients: env.get(InteractionClientProvider),
             scanners: env.get(ScannerSet),
-            netInterfaces: env.get(NetInterfaceSet),
+            transports: env.get(ConnectionlessTransportSet),
             sessions: env.get(SessionManager),
             exchanges: env.get(ExchangeManager),
             ca: env.get(CertificateAuthority),
@@ -213,7 +214,7 @@ export class ControllerCommissioner {
 
         if (
             this.#context.scanners.hasScannerFor(ChannelType.UDP) &&
-            this.#context.netInterfaces.hasInterfaceFor(ChannelType.UDP, "::") !== undefined
+            this.#context.transports.hasInterfaceFor(ChannelType.UDP, "::") !== undefined
         ) {
             discoveryCapabilities.onIpNetwork = true; // We always discover on network as defined by specs
         }
@@ -316,7 +317,7 @@ export class ControllerCommissioner {
             const { ip } = address;
 
             const isIpv6Address = isIPv6(ip);
-            const paseInterface = this.#context.netInterfaces.interfaceFor(
+            const paseInterface = this.#context.transports.interfaceFor(
                 ChannelType.UDP,
                 isIpv6Address ? "::" : "0.0.0.0",
             );
@@ -327,8 +328,8 @@ export class ControllerCommissioner {
                 );
             }
             paseChannel = await paseInterface.openChannel(address);
-        } else {
-            const ble = this.#context.netInterfaces.interfaceFor(ChannelType.BLE);
+        } else if (address.type === "ble") {
+            const ble = this.#context.transports.interfaceFor(ChannelType.BLE);
             if (!ble) {
                 throw new PairRetransmissionLimitReachedError(
                     `BLE interface not initialized. Cannot use ${address.peripheralAddress} for commissioning.`,
@@ -336,6 +337,8 @@ export class ControllerCommissioner {
             }
             // TODO Have a Timeout mechanism here for connections
             paseChannel = await ble.openChannel(address);
+        } else {
+            throw new ImplementationError(`Unsupported PASE address type ${address.type}`);
         }
 
         // Do PASE paring

package/src/peer/OperationalPeer.ts

@@ -5,7 +5,7 @@
  */
 
 import { DiscoveryData } from "#common/Scanner.js";
-import { ServerAddressIp } from "#general";
+import { ServerAddressUdp } from "#general";
 import type { PeerDataStore } from "#peer/PeerAddressStore.js";
 import { SessionParameters } from "#session/Session.js";
 import { PeerAddress } from "./PeerAddress.js";
@@ -24,7 +24,7 @@ export interface OperationalPeer {
     /**
      * A physical address the peer may be accessed at, if known.
      */
-    operationalAddress?: ServerAddressIp;
+    operationalAddress?: ServerAddressUdp;
 
     /**
      * The peer's session parameters reported during discovery.

package/src/peer/PeerAddressStore.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { ReadScope } from "#action/client/ReadScope.js";
 import { Construction, MaybePromise } from "#general";
 import { DecodedAttributeReportValue } from "#interaction/AttributeDataDecoder.js";
 import { AttributeId, ClusterId, EndpointNumber, EventNumber } from "#types";
@@ -27,7 +28,7 @@ export abstract class PeerDataStore {
     abstract maxEventNumber: EventNumber;
     abstract updateLastEventNumber(eventNumber: EventNumber): MaybePromise<void>;
 
-    abstract persistAttributes(attributes: DecodedAttributeReportValue<any>[]): MaybePromise<void>;
+    abstract persistAttributes(attributes: DecodedAttributeReportValue<any>[], scope: ReadScope): MaybePromise<void>;
 
     // TODO: Find a maybe better way to achieve this without functions
     abstract retrieveAttribute(
@@ -41,4 +42,5 @@ export abstract class PeerDataStore {
         filterEndpointId?: EndpointNumber,
         filterClusterId?: ClusterId,
     ): { endpointId: EndpointNumber; clusterId: ClusterId; dataVersion: number }[];
+    abstract cleanupAttributeData(endpointId: EndpointNumber, clusterIds?: ClusterId[]): MaybePromise<void>;
 }

package/src/peer/PeerSet.ts

@@ -10,6 +10,7 @@ import {
     AsyncObservable,
     BasicSet,
     ChannelType,
+    ConnectionlessTransportSet,
     Construction,
     createPromise,
     Duration,
@@ -22,12 +23,11 @@ import {
     Logger,
     MatterError,
     Minutes,
-    NetInterfaceSet,
     NoResponseTimeoutError,
     ObservableSet,
     Seconds,
     ServerAddress,
-    ServerAddressIp,
+    ServerAddressUdp,
     STANDARD_MATTER_PORT,
     Time,
     Timer,
@@ -109,7 +109,7 @@ export interface PeerSetContext {
     exchanges: ExchangeManager;
     subscriptionClient: SubscriptionClient;
     scanners: ScannerSet;
-    netInterfaces: NetInterfaceSet;
+    transports: ConnectionlessTransportSet;
     store: PeerAddressStore;
 }
 
@@ -122,7 +122,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     readonly #exchanges: ExchangeManager;
     readonly #subscriptionClient: SubscriptionClient;
     readonly #scanners: ScannerSet;
-    readonly #netInterfaces: NetInterfaceSet;
+    readonly #transports: ConnectionlessTransportSet;
     readonly #caseClient: CaseClient;
     readonly #peers = new BasicSet<OperationalPeer>();
     readonly #peersByAddress = new PeerAddressMap<OperationalPeer>();
@@ -138,14 +138,22 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     readonly #disconnected = AsyncObservable<[address: PeerAddress]>();
 
     constructor(context: PeerSetContext) {
-        const { sessions, channels, exchanges, subscriptionClient, scanners, netInterfaces, store } = context;
+        const {
+            sessions,
+            channels,
+            exchanges,
+            subscriptionClient,
+            scanners,
+            transports: netInterfaces,
+            store,
+        } = context;
 
         this.#sessions = sessions;
         this.#channels = channels;
         this.#exchanges = exchanges;
         this.#subscriptionClient = subscriptionClient;
         this.#scanners = scanners;
-        this.#netInterfaces = netInterfaces;
+        this.#transports = netInterfaces;
         this.#store = store;
         this.#caseClient = new CaseClient(this.#sessions);
 
@@ -231,7 +239,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
             exchanges: env.get(ExchangeManager),
             subscriptionClient: env.get(SubscriptionClient),
             scanners: env.get(ScannerSet),
-            netInterfaces: env.get(NetInterfaceSet),
+            transports: env.get(ConnectionlessTransportSet),
             store: env.get(PeerAddressStore),
         });
         env.set(PeerSet, instance);
@@ -257,7 +265,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         address: PeerAddress,
         options: PeerConnectionOptions & {
             allowUnknownPeer?: boolean;
-            operationalAddress?: ServerAddressIp;
+            operationalAddress?: ServerAddressUdp;
         },
     ) {
         address = PeerAddress(address);
@@ -422,7 +430,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
      * device is discovered again using its operational instance details.
      * It returns the operational MessageChannel on success.
      */
-    async #resume(address: PeerAddress, options: PeerConnectionOptions, tryOperationalAddress?: ServerAddressIp) {
+    async #resume(address: PeerAddress, options: PeerConnectionOptions, tryOperationalAddress?: ServerAddressUdp) {
         const { discoveryOptions: { discoveryType } = {} } = options;
 
         const operationalAddress =
@@ -449,7 +457,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
 
     async #connectOrDiscoverNode(
         address: PeerAddress,
-        operationalAddress?: ServerAddressIp,
+        operationalAddress?: ServerAddressUdp,
         options?: PeerConnectionOptions,
     ) {
         address = PeerAddress(address);
@@ -630,7 +638,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
 
     async #reconnectKnownAddress(
         address: PeerAddress,
-        operationalAddress: ServerAddressIp,
+        operationalAddress: ServerAddressUdp,
         discoveryData?: DiscoveryData,
         options?: CaseClient.PairOptions,
     ): Promise<MessageChannel | undefined> {
@@ -670,7 +678,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         GroupId.assertGroupId(groupId);
         const multicastAddress = this.#sessions.fabricFor(address).groups.multicastAddressFor(groupId);
 
-        const operationalInterface = this.#netInterfaces.interfaceFor(ChannelType.UDP, multicastAddress);
+        const operationalInterface = this.#transports.interfaceFor(ChannelType.UDP, multicastAddress);
         if (operationalInterface === undefined) {
             throw new PairRetransmissionLimitReachedError(`IPv6 interface not initialized`);
         }
@@ -689,7 +697,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     /** Pair with an operational device (already commissioned) and establish a CASE session. */
     async #pair(
         address: PeerAddress,
-        operationalServerAddress: ServerAddressIp,
+        operationalServerAddress: ServerAddressUdp,
         discoveryData?: DiscoveryData,
         options?: CaseClient.PairOptions,
     ) {
@@ -697,10 +705,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         const { ip, port } = operationalServerAddress;
         // Do CASE pairing
         const isIpv6Address = isIPv6(ip);
-        const operationalInterface = this.#netInterfaces.interfaceFor(
-            ChannelType.UDP,
-            isIpv6Address ? "::" : "0.0.0.0",
-        );
+        const operationalInterface = this.#transports.interfaceFor(ChannelType.UDP, isIpv6Address ? "::" : "0.0.0.0");
 
         if (operationalInterface === undefined) {
             throw new PairRetransmissionLimitReachedError(
@@ -812,7 +817,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
 
     async #addOrUpdatePeer(
         address: PeerAddress,
-        operationalServerAddress: ServerAddressIp,
+        operationalServerAddress: ServerAddressUdp,
         discoveryData?: DiscoveryData,
     ) {
         let peer = this.#peersByAddress.get(address);

package/src/protocol/ExchangeManager.ts

@@ -8,6 +8,8 @@ import { DecodedMessage, MessageCodec, SessionType } from "#codec/MessageCodec.j
 import {
     Bytes,
     Channel,
+    ConnectionlessTransport,
+    ConnectionlessTransportSet,
     Crypto,
     Diagnostic,
     Environment,
@@ -18,8 +20,6 @@ import {
     MatterError,
     MatterFlowError,
     ObserverGroup,
-    TransportInterface,
-    TransportInterfaceSet,
     UdpInterface,
     UnexpectedDataError,
 } from "#general";
@@ -49,35 +49,35 @@ const MAXIMUM_CONCURRENT_EXCHANGES_PER_SESSION = 5;
  */
 export interface ExchangeManagerContext {
     crypto: Crypto;
-    transportInterfaces: TransportInterfaceSet;
+    netInterface: ConnectionlessTransportSet;
     sessionManager: SessionManager;
     channelManager: ChannelManager;
 }
 
 export class ExchangeManager {
-    readonly #transportInterfaces: TransportInterfaceSet;
+    readonly #transports: ConnectionlessTransportSet;
     readonly #sessionManager: SessionManager;
     readonly #channelManager: ChannelManager;
     readonly #exchangeCounter: ExchangeCounter;
     readonly #exchanges = new Map<number, MessageExchange>();
     readonly #protocols = new Map<number, ProtocolHandler>();
-    readonly #listeners = new Map<TransportInterface, TransportInterface.Listener>();
+    readonly #listeners = new Map<ConnectionlessTransport, ConnectionlessTransport.Listener>();
     readonly #closers = new Set<Promise<void>>();
     readonly #observers = new ObserverGroup(this);
     #closing = false;
 
     constructor(context: ExchangeManagerContext) {
-        this.#transportInterfaces = context.transportInterfaces;
+        this.#transports = context.netInterface;
         this.#sessionManager = context.sessionManager;
         this.#channelManager = context.channelManager;
         this.#exchangeCounter = new ExchangeCounter(context.crypto);
 
-        for (const transportInterface of this.#transportInterfaces) {
-            this.#addListener(transportInterface);
+        for (const netInterface of this.#transports) {
+            this.#addListener(netInterface);
         }
 
-        this.#observers.on(this.#transportInterfaces.added, this.#addListener);
-        this.#observers.on(this.#transportInterfaces.deleted, this.#deleteListener);
+        this.#observers.on(this.#transports.added, this.#addListener);
+        this.#observers.on(this.#transports.deleted, this.#deleteListener);
 
         this.#observers.on(this.#sessionManager.sessions.deleted, session => {
             if (!session.closingAfterExchangeFinished) {
@@ -90,7 +90,7 @@ export class ExchangeManager {
     static [Environmental.create](env: Environment) {
         const instance = new ExchangeManager({
             crypto: env.get(Crypto),
-            transportInterfaces: env.get(TransportInterfaceSet),
+            netInterface: env.get(ConnectionlessTransportSet),
             sessionManager: env.get(SessionManager),
             channelManager: env.get(ChannelManager),
         });
@@ -261,7 +261,11 @@ export class ExchangeManager {
 
             // Having a "Secure Session" means it is encrypted in our internal working
             // TODO When adding Group sessions, we need to check how to adjust that handling
-            if (protocolHandler !== undefined && protocolHandler.requiresSecureSession !== session.isSecure) {
+            if (
+                protocolHandler !== undefined &&
+                protocolHandler.requiresSecureSession !== session.isSecure &&
+                !isStandaloneAck
+            ) {
                 logger.debug(
                     `Ignoring message ${messageId} for protocol ${message.payloadHeader.protocolId} and exchange id ${message.payloadHeader.exchangeId} on channel ${channel.name} because not matching the security requirements.`,
                 );
@@ -313,7 +317,7 @@ export class ExchangeManager {
                         );
                     }
                     return;
-                } else {
+                } else if (!isStandaloneAck) {
                     logger.info(
                         `Discarding unexpected message ${messageId} for protocol ${
                             message.payloadHeader.protocolId
@@ -416,7 +420,11 @@ export class ExchangeManager {
         channel: MessageChannel,
         expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
     ) {
-        return channel.calculateMaximumPeerResponseTime(this.#sessionManager.sessionParameters, expectedProcessingTime);
+        return channel.calculateMaximumPeerResponseTime(
+            channel.session.parameters,
+            this.#sessionManager.sessionParameters,
+            expectedProcessingTime,
+        );
     }
 
     #messageExchangeContextFor(channel: MessageChannel): MessageExchangeContext {
@@ -427,11 +435,11 @@ export class ExchangeManager {
         };
     }
 
-    #addListener(transportInterface: TransportInterface) {
-        const udpInterface = transportInterface instanceof UdpInterface;
+    #addListener(netInterface: ConnectionlessTransport) {
+        const udpInterface = netInterface instanceof UdpInterface;
         this.#listeners.set(
-            transportInterface,
-            transportInterface.onData((socket, data) => {
+            netInterface,
+            netInterface.onData((socket, data) => {
                 if (udpInterface && data.byteLength > socket.maxPayloadSize) {
                     logger.warn(
                         `Ignoring UDP message on channel ${socket.name} with size ${data.byteLength} from ${socket.name}, which is larger than the maximum allowed size of ${socket.maxPayloadSize}.`,
@@ -456,12 +464,12 @@ export class ExchangeManager {
         );
     }
 
-    #deleteListener(transportInterface: TransportInterface) {
-        const listener = this.#listeners.get(transportInterface);
+    #deleteListener(netInterface: ConnectionlessTransport) {
+        const listener = this.#listeners.get(netInterface);
         if (listener === undefined) {
             return;
         }
-        this.#listeners.delete(transportInterface);
+        this.#listeners.delete(netInterface);
 
         const closer = listener
             .close()

package/src/protocol/MessageChannel.ts

@@ -114,7 +114,8 @@ export class MessageChannel implements Channel<Message> {
     }
 
     calculateMaximumPeerResponseTime(
-        sessionParameters: SessionParameters,
+        peerSessionParameters: SessionParameters,
+        localSessionParameters: SessionParameters,
         expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
     ): Duration {
         switch (this.channel.type) {
@@ -127,8 +128,11 @@ export class MessageChannel implements Channel<Message> {
                 if (!this.usesMrp) {
                     throw new MatterFlowError("No response expected for this message exchange because UDP and no MRP.");
                 }
+                // Calculate the maximum time till the peer got our last retry and worst case for the way back
                 return Millis(
-                    this.#calculateMrpMaximumPeerResponseTime(sessionParameters, expectedProcessingTime) +
+                    this.#calculateMrpMaximumPeerResponseTime(peerSessionParameters) +
+                        this.#calculateMrpMaximumPeerResponseTime(localSessionParameters) +
+                        expectedProcessingTime +
                         PEER_RESPONSE_TIME_BUFFER,
                 );
 
@@ -153,8 +157,10 @@ export class MessageChannel implements Channel<Message> {
      */
     getMrpResubmissionBackOffTime(retransmissionCount: number, sessionParameters?: SessionParameters) {
         const { activeInterval, idleInterval } = sessionParameters ?? this.session.parameters;
-        const baseInterval =
-            sessionParameters !== undefined || this.session.isPeerActive() ? activeInterval : idleInterval;
+        // For the first message of a new exchange ... SHALL be set according to the idle state of the peer node.
+        // For all subsequent messages of the exchange, ... SHOULD be set according to the active state of the peer node
+        const peerActive = retransmissionCount > 0 && (sessionParameters !== undefined || this.session.isPeerActive());
+        const baseInterval = peerActive ? activeInterval : idleInterval;
         return Millis.floor(
             Millis(
                 baseInterval *
@@ -165,19 +171,15 @@ export class MessageChannel implements Channel<Message> {
         );
     }
 
-    #calculateMrpMaximumPeerResponseTime(
-        sessionParameters: SessionParameters,
-        expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
-    ) {
-        // We use the expected processing time and deduct the time we already waited since last resubmission
-        let finalWaitTime = expectedProcessingTime;
+    /** Calculates the maximum time the peer might take to respond when using MRP for one direction. */
+    #calculateMrpMaximumPeerResponseTime(sessionParameters: SessionParameters) {
+        let finalWaitTime = 0;
 
         // and then add the time the other side needs for a full resubmission cycle under the assumption we are active
         for (let i = 0; i < MRP.MAX_TRANSMISSIONS; i++) {
             finalWaitTime = Millis(finalWaitTime + this.getMrpResubmissionBackOffTime(i, sessionParameters));
         }
 
-        // TODO: Also add any network latency buffer, for now lets consider it's included in the processing time already
         return finalWaitTime;
     }
 }

package/src/protocol/MessageExchange.ts

@@ -31,7 +31,6 @@ import {
 } from "#protocol/MessageChannel.js";
 import { GroupSession } from "#session/GroupSession.js";
 import { SessionParameters } from "#session/Session.js";
-import { SessionIntervals } from "#session/SessionIntervals.js";
 import {
     GroupId,
     NodeId,
@@ -145,9 +144,6 @@ export class MessageExchange {
         );
     }
 
-    readonly #activeInterval: Duration;
-    readonly #idleInterval: Duration;
-    readonly #activeThreshold: Duration;
     readonly #messagesQueue = new DataReadQueue<Message>();
     #receivedMessageToAck: Message | undefined;
     #receivedMessageAckTimer = Time.getTimer("Ack receipt timeout", MRP.STANDALONE_ACK_TIMEOUT, () => {
@@ -196,10 +192,7 @@ export class MessageExchange {
         this.#exchangeId = exchangeId;
         this.#protocolId = protocolId;
 
-        const { activeInterval, idleInterval, activeThreshold } = SessionIntervals(session.parameters);
-        this.#activeInterval = activeInterval;
-        this.#idleInterval = idleInterval;
-        this.#activeThreshold = activeThreshold;
+        const { activeThreshold, activeInterval, idleInterval } = this.session.parameters;
 
         this.#used = !isInitiator; // If we are the initiator then exchange was not used yet, so track it
 
@@ -211,9 +204,9 @@ export class MessageExchange {
                 exId: this.#exchangeId,
                 sess: session.name,
                 peerSess: this.#peerSessionId,
-                SAT: this.#activeThreshold,
-                SAI: this.#activeInterval,
-                SII: this.#idleInterval,
+                SAT: Duration.format(activeThreshold),
+                SAI: Duration.format(activeInterval),
+                SII: Duration.format(idleInterval),
                 maxTrans: MRP.MAX_TRANSMISSIONS,
                 exchangeFlags: Diagnostic.asFlags({
                     MRP: this.channel.usesMrp,
@@ -489,6 +482,7 @@ export class MessageExchange {
             timeout = Instant; // If we have messages in the queue, we can return them immediately
         } else {
             timeout = this.channel.calculateMaximumPeerResponseTime(
+                this.session.parameters,
                 this.context.localSessionParameters,
                 options?.expectedProcessingTime,
             );
@@ -496,13 +490,6 @@ export class MessageExchange {
         return this.#messagesQueue.read(timeout);
     }
 
-    calculateMaximumPeerResponseTimeMs(expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME) {
-        return this.channel.calculateMaximumPeerResponseTime(
-            this.context.localSessionParameters,
-            expectedProcessingTimeMs,
-        );
-    }
-
     #retransmitMessage(message: Message, expectedProcessingTime?: Duration) {
         this.#retransmissionCounter++;
         if (this.#retransmissionCounter >= MRP.MAX_TRANSMISSIONS) {
@@ -512,6 +499,7 @@ export class MessageExchange {
                 // We already have waited after the last message was sent, so deduct this time from the final wait time
                 const finalWaitTime = Millis(
                     this.channel.calculateMaximumPeerResponseTime(
+                        this.session.parameters,
                         this.context.localSessionParameters,
                         expectedProcessingTime,
                     ) - (this.#retransmissionTimer?.interval ?? Instant),

package/src/session/NodeSession.ts

@@ -13,6 +13,7 @@ import {
     CRYPTO_SYMMETRIC_KEY_LENGTH,
     Crypto,
     Diagnostic,
+    Duration,
     Logger,
     MatterError,
     MatterFlowError,
@@ -176,9 +177,9 @@ export class NodeSession extends SecureSession {
     get parameterDiagnostics() {
         return Diagnostic.dict(
             {
-                SII: this.idleInterval,
-                SAI: this.activeInterval,
-                SAT: this.activeThreshold,
+                SII: Duration.format(this.idleInterval),
+                SAI: Duration.format(this.activeInterval),
+                SAT: Duration.format(this.activeThreshold),
                 DMRev: this.dataModelRevision,
                 IMRev: this.interactionModelRevision,
                 spec: Diagnostic.hex(this.specificationVersion),

package/src/session/SessionIntervals.ts

@@ -49,7 +49,7 @@ export function SessionIntervals(intervals?: Partial<SessionIntervals>): Session
 }
 
 export namespace SessionIntervals {
-    export const defaults = {
+    export const defaults: SessionIntervals = {
         idleInterval: Millis(500),
         activeInterval: Millis(300),
         activeThreshold: Seconds(4),