@matter/protocol 0.16.0-alpha.0-20250816-d22ad240d → 0.16.0-alpha.0-20250819-0a388db8b

package/src/protocol/MessageChannel.ts

@@ -5,7 +5,7 @@
  */
 
 import { Message, MessageCodec } from "#codec/MessageCodec.js";
-import { Bytes, Channel, Logger, MatterError, MatterFlowError } from "#general";
+import { Bytes, Channel, Duration, Logger, MatterError, MatterFlowError, Millis, Seconds } from "#general";
 import type { ExchangeLogContext } from "#protocol/MessageExchange.js";
 import { Session, SessionParameters } from "#session/Session.js";
 
@@ -18,13 +18,13 @@ export class ChannelNotConnectedError extends MatterError {}
  * from chip implementation. This is basically the default used with different names, also kExpectedLowProcessingTime or
  * kExpectedSigma1ProcessingTime.
  */
-export const DEFAULT_EXPECTED_PROCESSING_TIME_MS = 2000;
+export const DEFAULT_EXPECTED_PROCESSING_TIME = Seconds(2);
 
 /**
  * The buffer time in milliseconds to add to the peer response time to also consider network delays and other factors.
  * TODO: This is a pure guess and should be adjusted in the future.
  */
-const PEER_RESPONSE_TIME_BUFFER_MS = 5_000;
+const PEER_RESPONSE_TIME_BUFFER = Seconds(5);
 
 export namespace MRP {
     /**
@@ -46,7 +46,7 @@ export namespace MRP {
     export const BACKOFF_THRESHOLD = 1;
 
     /** @see {@link MatterSpecification.v12.Core}, section 4.11.8 */
-    export const STANDALONE_ACK_TIMEOUT_MS = 200;
+    export const STANDALONE_ACK_TIMEOUT = Millis(200);
 }
 
 export class MessageChannel implements Channel<Message> {
@@ -113,26 +113,29 @@ export class MessageChannel implements Channel<Message> {
         }
     }
 
-    calculateMaximumPeerResponseTimeMs(
+    calculateMaximumPeerResponseTime(
         sessionParameters: SessionParameters,
-        expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS,
-    ) {
+        expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
+    ): Duration {
         switch (this.channel.type) {
             case "tcp":
                 // TCP uses 30s timeout according to chip sdk implementation, so do the same
-                return 30_000 + PEER_RESPONSE_TIME_BUFFER_MS;
+                return Millis(Seconds(30) + PEER_RESPONSE_TIME_BUFFER);
+
             case "udp":
                 // UDP normally uses MRP, if not we have Group communication, which normally have no responses
                 if (!this.usesMrp) {
                     throw new MatterFlowError("No response expected for this message exchange because UDP and no MRP.");
                 }
-                return (
-                    this.#calculateMrpMaximumPeerResponseTime(sessionParameters, expectedProcessingTimeMs) +
-                    PEER_RESPONSE_TIME_BUFFER_MS
+                return Millis(
+                    this.#calculateMrpMaximumPeerResponseTime(sessionParameters, expectedProcessingTime) +
+                        PEER_RESPONSE_TIME_BUFFER,
                 );
+
             case "ble":
                 // chip sdk uses BTP_ACK_TIMEOUT_MS which is wrong in my eyes, so we use static 30s as like TCP here
-                return 30_000 + PEER_RESPONSE_TIME_BUFFER_MS;
+                return Millis(Seconds(30) + PEER_RESPONSE_TIME_BUFFER);
+
             default:
                 throw new MatterFlowError(
                     `Can not calculate expected timeout for unknown channel type: ${this.channel.type}`,
@@ -149,27 +152,29 @@ export class MessageChannel implements Channel<Message> {
      * @see {@link MatterSpecification.v10.Core}, section 4.11.2.1
      */
     getMrpResubmissionBackOffTime(retransmissionCount: number, sessionParameters?: SessionParameters) {
-        const { activeIntervalMs, idleIntervalMs } = sessionParameters ?? this.session.parameters;
+        const { activeInterval, idleInterval } = sessionParameters ?? this.session.parameters;
         const baseInterval =
-            sessionParameters !== undefined || this.session.isPeerActive() ? activeIntervalMs : idleIntervalMs;
-        return Math.floor(
-            MRP.BACKOFF_MARGIN *
+            sessionParameters !== undefined || this.session.isPeerActive() ? activeInterval : idleInterval;
+        return Millis.floor(
+            Millis(
                 baseInterval *
-                Math.pow(MRP.BACKOFF_BASE, Math.max(0, retransmissionCount - MRP.BACKOFF_THRESHOLD)) *
-                (1 + (sessionParameters !== undefined ? 1 : Math.random()) * MRP.BACKOFF_JITTER),
+                    MRP.BACKOFF_MARGIN *
+                    Math.pow(MRP.BACKOFF_BASE, Math.max(0, retransmissionCount - MRP.BACKOFF_THRESHOLD)) *
+                    (1 + (sessionParameters !== undefined ? 1 : Math.random()) * MRP.BACKOFF_JITTER),
+            ),
         );
     }
 
     #calculateMrpMaximumPeerResponseTime(
         sessionParameters: SessionParameters,
-        expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS,
+        expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
     ) {
         // We use the expected processing time and deduct the time we already waited since last resubmission
-        let finalWaitTime = expectedProcessingTimeMs;
+        let finalWaitTime = expectedProcessingTime;
 
         // 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 += this.getMrpResubmissionBackOffTime(i, sessionParameters);
+            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

package/src/protocol/MessageExchange.ts

@@ -12,17 +12,20 @@ import {
     CRYPTO_AEAD_MIC_LENGTH_BYTES,
     DataReadQueue,
     Diagnostic,
+    Duration,
+    Instant,
     InternalError,
     Logger,
     MatterError,
     MatterFlowError,
+    Millis,
     NoResponseTimeoutError,
     Time,
     Timer,
 } from "#general";
 import {
     ChannelNotConnectedError,
-    DEFAULT_EXPECTED_PROCESSING_TIME_MS,
+    DEFAULT_EXPECTED_PROCESSING_TIME,
     MessageChannel,
     MRP,
 } from "#protocol/MessageChannel.js";
@@ -70,7 +73,7 @@ export type ExchangeSendOptions = {
      * Defined an expected processing time by the responder for the message. This is used to calculate the final
      * timeout for responses together with the normal retransmission logic when MRP is used.
      */
-    expectedProcessingTimeMs?: number;
+    expectedProcessingTime?: Duration;
 
     /** Allows to specify if the send message requires to be acknowledged by the receiver or not. */
     requiresAck?: boolean;
@@ -137,12 +140,12 @@ export class MessageExchange {
         );
     }
 
-    readonly #activeIntervalMs: number;
-    readonly #idleIntervalMs: number;
-    readonly #activeThresholdMs: number;
+    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_MS, () => {
+    #receivedMessageAckTimer = Time.getTimer("Ack receipt timeout", MRP.STANDALONE_ACK_TIMEOUT, () => {
         if (this.#receivedMessageToAck !== undefined) {
             const messageToAck = this.#receivedMessageToAck;
             this.#receivedMessageToAck = undefined;
@@ -188,10 +191,10 @@ export class MessageExchange {
         this.#exchangeId = exchangeId;
         this.#protocolId = protocolId;
 
-        const { activeIntervalMs, idleIntervalMs, activeThresholdMs } = SessionIntervals(session.parameters);
-        this.#activeIntervalMs = activeIntervalMs;
-        this.#idleIntervalMs = idleIntervalMs;
-        this.#activeThresholdMs = activeThresholdMs;
+        const { activeInterval, idleInterval, activeThreshold } = SessionIntervals(session.parameters);
+        this.#activeInterval = activeInterval;
+        this.#idleInterval = idleInterval;
+        this.#activeThreshold = activeThreshold;
 
         this.#used = !isInitiator; // If we are the initiator then exchange was not used yet, so track it
 
@@ -203,9 +206,9 @@ export class MessageExchange {
                 exId: this.#exchangeId,
                 sess: session.name,
                 peerSess: this.#peerSessionId,
-                SAT: this.#activeThresholdMs,
-                SAI: this.#activeIntervalMs,
-                SII: this.#idleIntervalMs,
+                SAT: this.#activeThreshold,
+                SAI: this.#activeInterval,
+                SII: this.#idleInterval,
                 maxTrans: MRP.MAX_TRANSMISSIONS,
                 exchangeFlags: Diagnostic.asFlags({
                     MRP: this.channel.usesMrp,
@@ -353,7 +356,7 @@ export class MessageExchange {
         const {
             expectAckOnly = false,
             disableMrpLogic,
-            expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS,
+            expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
             requiresAck,
             includeAcknowledgeMessageId,
             logContext,
@@ -440,7 +443,7 @@ export class MessageExchange {
             this.#retransmissionTimer = Time.getTimer(
                 `Message retransmission ${message.packetHeader.messageId}`,
                 this.channel.getMrpResubmissionBackOffTime(0),
-                () => this.#retransmitMessage(message, expectedProcessingTimeMs),
+                () => this.#retransmitMessage(message, expectedProcessingTime),
             );
             const { promise, resolver, rejecter } = createPromise<Message>();
             ackPromise = promise;
@@ -467,40 +470,41 @@ export class MessageExchange {
         }
     }
 
-    nextMessage(options?: { expectedProcessingTimeMs?: number; timeoutMs?: number }) {
-        let timeout: number;
-        if (options?.timeoutMs !== undefined) {
-            timeout = options.timeoutMs;
+    nextMessage(options?: { expectedProcessingTime?: Duration; timeout?: Duration }) {
+        let timeout: Duration;
+        if (options?.timeout !== undefined) {
+            timeout = options.timeout;
         } else if (this.#messagesQueue.size > 0) {
-            timeout = 0; // If we have messages in the queue, we can return them immediately
+            timeout = Instant; // If we have messages in the queue, we can return them immediately
         } else {
-            timeout = this.channel.calculateMaximumPeerResponseTimeMs(
+            timeout = this.channel.calculateMaximumPeerResponseTime(
                 this.context.localSessionParameters,
-                options?.expectedProcessingTimeMs,
+                options?.expectedProcessingTime,
             );
         }
         return this.#messagesQueue.read(timeout);
     }
 
-    calculateMaximumPeerResponseTimeMs(expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS) {
-        return this.channel.calculateMaximumPeerResponseTimeMs(
+    calculateMaximumPeerResponseTimeMs(expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME) {
+        return this.channel.calculateMaximumPeerResponseTime(
             this.context.localSessionParameters,
             expectedProcessingTimeMs,
         );
     }
 
-    #retransmitMessage(message: Message, expectedProcessingTimeMs?: number) {
+    #retransmitMessage(message: Message, expectedProcessingTime?: Duration) {
         this.#retransmissionCounter++;
         if (this.#retransmissionCounter >= MRP.MAX_TRANSMISSIONS) {
             // Ok all 4 resubmissions are done, but we need to wait a bit longer because of processing time and
             // the resubmissions from the other side
-            if (expectedProcessingTimeMs !== undefined) {
+            if (expectedProcessingTime) {
                 // We already have waited after the last message was sent, so deduct this time from the final wait time
-                const finalWaitTime =
-                    this.channel.calculateMaximumPeerResponseTimeMs(
+                const finalWaitTime = Millis(
+                    this.channel.calculateMaximumPeerResponseTime(
                         this.context.localSessionParameters,
-                        expectedProcessingTimeMs,
-                    ) - (this.#retransmissionTimer?.intervalMs ?? 0);
+                        expectedProcessingTime,
+                    ) - (this.#retransmissionTimer?.interval ?? Instant),
+                );
                 if (finalWaitTime > 0) {
                     this.#retransmissionCounter--; // We will not resubmit the message again
                     logger.debug(
@@ -539,18 +543,18 @@ export class MessageExchange {
 
         this.channel
             .send(message)
-            .then(() => this.#initializeResubmission(message, resubmissionBackoffTime, expectedProcessingTimeMs))
+            .then(() => this.#initializeResubmission(message, resubmissionBackoffTime, expectedProcessingTime))
             .catch(error => {
                 logger.error("An error happened when retransmitting a message", error);
                 if (error instanceof ChannelNotConnectedError) {
                     this.#close().catch(error => logger.error("An error happened when closing the exchange", error));
                 } else {
-                    this.#initializeResubmission(message, resubmissionBackoffTime, expectedProcessingTimeMs);
+                    this.#initializeResubmission(message, resubmissionBackoffTime, expectedProcessingTime);
                 }
             });
     }
 
-    #initializeResubmission(message: Message, resubmissionBackoffTime: number, expectedProcessingTimeMs?: number) {
+    #initializeResubmission(message: Message, resubmissionBackoffTime: Duration, expectedProcessingTimeMs?: Duration) {
         this.#retransmissionTimer = Time.getTimer("Message retransmission", resubmissionBackoffTime, () =>
             this.#retransmitMessage(message, expectedProcessingTimeMs),
         ).start();
@@ -570,7 +574,7 @@ export class MessageExchange {
         await this.#close();
     }
 
-    startTimedInteraction(timeoutMs: number) {
+    startTimedInteraction(timeout: Duration) {
         if (this.#timedInteractionTimer !== undefined && this.#timedInteractionTimer.isRunning) {
             this.#timedInteractionTimer.stop();
             throw new StatusResponseError(
@@ -579,9 +583,9 @@ export class MessageExchange {
             );
         }
         logger.debug(
-            `Starting timed interaction with Transaction ID ${this.#exchangeId} for ${timeoutMs}ms from ${this.channel.name}`,
+            `Starting timed interaction with Transaction ID ${this.#exchangeId} for ${Duration.format(timeout)} from ${this.channel.name}`,
         );
-        this.#timedInteractionTimer = Time.getTimer("Timed interaction", timeoutMs, () => {
+        this.#timedInteractionTimer = Time.getTimer("Timed interaction", timeout, () => {
             logger.debug(
                 `Timed interaction with Transaction ID ${this.#exchangeId} from ${this.channel.name} timed out`,
             );
@@ -653,9 +657,9 @@ export class MessageExchange {
         // Wait until all potential Resubmissions are done, also for Standalone-Acks.
         // We might wait a bit longer then needed but because this is mainly a failsafe mechanism it is acceptable.
         // in normal case this timer is cancelled before it triggers when all retries are done.
-        let maxResubmissionTime = 0;
+        let maxResubmissionTime = Instant;
         for (let i = this.#retransmissionCounter; i <= MRP.MAX_TRANSMISSIONS; i++) {
-            maxResubmissionTime += this.channel.getMrpResubmissionBackOffTime(i);
+            maxResubmissionTime = Millis(maxResubmissionTime + this.channel.getMrpResubmissionBackOffTime(i));
         }
         this.#closeTimer = Time.getTimer(
             `Message exchange cleanup ${this.session.name} / ${this.#exchangeId}`,

package/src/securechannel/SecureChannelMessenger.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Diagnostic, MatterError, UnexpectedDataError } from "#general";
+import { Diagnostic, Duration, MatterError, Seconds, UnexpectedDataError } from "#general";
 import { GeneralStatusCode, SecureChannelStatusCode, SecureMessageType, TlvSchema } from "#types";
 import { Message } from "../codec/MessageCodec.js";
 import { ExchangeSendOptions, MessageExchange } from "../protocol/MessageExchange.js";
@@ -24,19 +24,19 @@ export class ChannelStatusResponseError extends MatterError {
 }
 
 /** This value is used by chip SDK when performance wise heavy crypto operations are expected. */
-export const EXPECTED_CRYPTO_PROCESSING_TIME_MS = 30_000;
+export const EXPECTED_CRYPTO_PROCESSING_TIME = Seconds(30);
 
 /** This value is used by chip SDK when normal processing time is expected. */
-export const DEFAULT_NORMAL_PROCESSING_TIME_MS = 2_000;
+export const DEFAULT_NORMAL_PROCESSING_TIME = Seconds(2);
 
 export class SecureChannelMessenger {
-    #defaultExpectedProcessingTimeMs: number;
+    #defaultExpectedProcessingTime: Duration;
 
     constructor(
         protected readonly exchange: MessageExchange,
-        defaultExpectedProcessingTimeMs = EXPECTED_CRYPTO_PROCESSING_TIME_MS,
+        defaultExpectedProcessingTime = EXPECTED_CRYPTO_PROCESSING_TIME,
     ) {
-        this.#defaultExpectedProcessingTimeMs = defaultExpectedProcessingTimeMs;
+        this.#defaultExpectedProcessingTime = defaultExpectedProcessingTime;
     }
 
     get channel() {
@@ -45,17 +45,14 @@ export class SecureChannelMessenger {
 
     async nextMessage(
         expectedMessageType: number,
-        expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs,
+        expectedProcessingTimeMs = this.#defaultExpectedProcessingTime,
         expectedMessageInfo?: string,
     ) {
         return this.#nextMessage(expectedMessageType, expectedProcessingTimeMs, expectedMessageInfo);
     }
 
-    async anyNextMessage(
-        expectedMessageInfo: string,
-        expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs,
-    ) {
-        return this.#nextMessage(undefined, expectedProcessingTimeMs, expectedMessageInfo);
+    async anyNextMessage(expectedMessageInfo: string, expectedProcessingTime = this.#defaultExpectedProcessingTime) {
+        return this.#nextMessage(undefined, expectedProcessingTime, expectedMessageInfo);
     }
 
     /**
@@ -65,10 +62,10 @@ export class SecureChannelMessenger {
      */
     async #nextMessage(
         expectedMessageType?: number,
-        expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs,
+        expectedProcessingTime = this.#defaultExpectedProcessingTime,
         expectedMessageInfo?: string,
     ) {
-        const message = await this.exchange.nextMessage({ expectedProcessingTimeMs });
+        const message = await this.exchange.nextMessage({ expectedProcessingTime });
         const messageType = message.payloadHeader.messageType;
         if (expectedMessageType !== undefined && expectedMessageInfo === undefined) {
             expectedMessageInfo = SecureMessageType[expectedMessageType];
@@ -89,9 +86,9 @@ export class SecureChannelMessenger {
     async nextMessageDecoded<T>(
         expectedMessageType: number,
         schema: TlvSchema<T>,
-        expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs,
+        expectedProcessingTime = this.#defaultExpectedProcessingTime,
     ) {
-        return schema.decode((await this.nextMessage(expectedMessageType, expectedProcessingTimeMs)).payload);
+        return schema.decode((await this.nextMessage(expectedMessageType, expectedProcessingTime)).payload);
     }
 
     /**
@@ -99,12 +96,9 @@ export class SecureChannelMessenger {
      *
      * When no expectedProcessingTimeMs is provided, the default value of EXPECTED_CRYPTO_PROCESSING_TIME_MS is used.
      */
-    async waitForSuccess(
-        expectedMessageInfo: string,
-        expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs,
-    ) {
+    async waitForSuccess(expectedMessageInfo: string, expectedProcessingTime = this.#defaultExpectedProcessingTime) {
         // If the status is not Success, this would throw an Error.
-        await this.nextMessage(SecureMessageType.StatusReport, expectedProcessingTimeMs, expectedMessageInfo);
+        await this.nextMessage(SecureMessageType.StatusReport, expectedProcessingTime, expectedMessageInfo);
     }
 
     /**
@@ -116,7 +110,7 @@ export class SecureChannelMessenger {
     async send<T>(message: T, type: number, schema: TlvSchema<T>, options?: ExchangeSendOptions) {
         options = {
             ...options,
-            expectedProcessingTimeMs: options?.expectedProcessingTimeMs ?? this.#defaultExpectedProcessingTimeMs,
+            expectedProcessingTime: options?.expectedProcessingTime ?? this.#defaultExpectedProcessingTime,
         };
         const payload = schema.encode(message);
         await this.exchange.send(type, payload, options);

package/src/session/InsecureSession.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Crypto, Logger, MatterFlowError } from "#general";
+import { Bytes, Crypto, Logger, MatterFlowError } from "#general";
 import { NodeId } from "#types";
 import { DecodedMessage, DecodedPacket, Message, MessageCodec, Packet, SessionType } from "../codec/MessageCodec.js";
 import { Fabric } from "../fabric/Fabric.js";
@@ -57,7 +57,7 @@ export class InsecureSession extends Session {
         return MessageCodec.encodePayload(message);
     }
 
-    get attestationChallengeKey(): BufferSource {
+    get attestationChallengeKey(): Bytes {
         throw new MatterFlowError("Not supported on an unsecure session");
     }
 

package/src/session/NodeSession.ts

@@ -176,9 +176,9 @@ export class NodeSession extends SecureSession {
     parameterDiagnostics() {
         return Diagnostic.dict(
             {
-                SII: this.idleIntervalMs,
-                SAI: this.activeIntervalMs,
-                SAT: this.activeThresholdMs,
+                SII: this.idleInterval,
+                SAI: this.activeInterval,
+                SAT: this.activeThreshold,
                 DMRev: this.dataModelRevision,
                 IMRev: this.interactionModelRevision,
                 spec: Diagnostic.hex(this.specificationVersion),

package/src/session/Session.ts

@@ -5,7 +5,17 @@
  */
 
 import { SupportedTransportsBitmap } from "#common/SupportedTransportsBitmap.js";
-import { AsyncObservable, Bytes, DataWriter, Endian, InternalError, Time } from "#general";
+import {
+    AsyncObservable,
+    Bytes,
+    DataWriter,
+    Duration,
+    Endian,
+    InternalError,
+    Time,
+    Timespan,
+    Timestamp,
+} from "#general";
 import { NodeId, TypeFromPartialBitSchema } from "#types";
 import { DecodedMessage, DecodedPacket, Message, Packet, SessionType } from "../codec/MessageCodec.js";
 import { Fabric } from "../fabric/Fabric.js";
@@ -64,13 +74,13 @@ export abstract class Session {
     abstract get name(): string;
     abstract get closingAfterExchangeFinished(): boolean;
     #manager?: SessionManager;
-    timestamp = Time.nowMs();
-    readonly createdAt = Time.nowMs();
-    activeTimestamp = 0;
+    timestamp = Time.nowMs;
+    readonly createdAt = Time.nowMs;
+    activeTimestamp: Timestamp = 0;
     abstract type: SessionType;
-    protected readonly idleIntervalMs: number;
-    protected readonly activeIntervalMs: number;
-    protected readonly activeThresholdMs: number;
+    protected readonly idleInterval: Duration;
+    protected readonly activeInterval: Duration;
+    protected readonly activeThreshold: Duration;
     protected readonly dataModelRevision: number;
     protected readonly interactionModelRevision: number;
     protected readonly specificationVersion: number;
@@ -100,9 +110,9 @@ export abstract class Session {
             messageCounter,
             messageReceptionState,
             sessionParameters: {
-                idleIntervalMs = SessionIntervals.defaults.idleIntervalMs,
-                activeIntervalMs = SessionIntervals.defaults.activeIntervalMs,
-                activeThresholdMs = SessionIntervals.defaults.activeThresholdMs,
+                idleInterval = SessionIntervals.defaults.idleInterval,
+                activeInterval = SessionIntervals.defaults.activeInterval,
+                activeThreshold = SessionIntervals.defaults.activeThreshold,
                 dataModelRevision = FALLBACK_DATAMODEL_REVISION,
                 interactionModelRevision = FALLBACK_INTERACTIONMODEL_REVISION,
                 specificationVersion = FALLBACK_SPECIFICATION_VERSION,
@@ -115,9 +125,9 @@ export abstract class Session {
         this.#manager = manager;
         this.messageCounter = messageCounter;
         this.messageReceptionState = messageReceptionState;
-        this.idleIntervalMs = idleIntervalMs;
-        this.activeIntervalMs = activeIntervalMs;
-        this.activeThresholdMs = activeThresholdMs;
+        this.idleInterval = idleInterval;
+        this.activeInterval = activeInterval;
+        this.activeThreshold = activeThreshold;
         this.dataModelRevision = dataModelRevision;
         this.interactionModelRevision = interactionModelRevision;
         this.specificationVersion = specificationVersion;
@@ -134,7 +144,7 @@ export abstract class Session {
     }
 
     notifyActivity(messageReceived: boolean) {
-        this.timestamp = Time.nowMs();
+        this.timestamp = Time.nowMs;
         if (messageReceived) {
             // only update active timestamp if we received a message
             this.activeTimestamp = this.timestamp;
@@ -142,7 +152,7 @@ export abstract class Session {
     }
 
     isPeerActive(): boolean {
-        return Time.nowMs() - this.activeTimestamp < this.activeThresholdMs;
+        return Timespan(this.activeTimestamp, Time.nowMs).duration < this.activeThreshold;
     }
 
     getIncrementedMessageCounter() {
@@ -169,9 +179,9 @@ export abstract class Session {
      */
     get parameters(): SessionParameters {
         const {
-            idleIntervalMs,
-            activeIntervalMs,
-            activeThresholdMs,
+            idleInterval,
+            activeInterval,
+            activeThreshold,
             dataModelRevision,
             interactionModelRevision,
             specificationVersion,
@@ -180,9 +190,9 @@ export abstract class Session {
             maxTcpMessageSize,
         } = this;
         return {
-            idleIntervalMs,
-            activeIntervalMs,
-            activeThresholdMs,
+            idleInterval,
+            activeInterval,
+            activeThreshold,
             dataModelRevision,
             interactionModelRevision,
             specificationVersion,

package/src/session/SessionIntervals.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { ImplementationError } from "@matter/general";
+import { Duration, Hours, ImplementationError, Millis, Seconds } from "#general";
 
 export interface SessionIntervals {
     /**
@@ -13,7 +13,7 @@ export interface SessionIntervals {
      *
      * Default: 500ms
      */
-    idleIntervalMs: number;
+    idleInterval: Duration;
 
     /**
      * Minimum amount of time between sender retries when the destination node is active. This SHALL be greater than or
@@ -21,27 +21,27 @@ export interface SessionIntervals {
      *
      * Default: 300ms
      */
-    activeIntervalMs: number;
+    activeInterval: Duration;
 
     /**
      * Minimum amount of time the node SHOULD stay active after network activity.
      *
      * Default: 4000ms
      */
-    activeThresholdMs: number;
+    activeThreshold: Duration;
 }
 
 export function SessionIntervals(intervals?: Partial<SessionIntervals>): SessionIntervals {
     const reified = { ...SessionIntervals.defaults, ...intervals };
-    const { idleIntervalMs, activeIntervalMs, activeThresholdMs } = reified;
+    const { idleInterval, activeInterval, activeThreshold } = reified;
 
-    if (idleIntervalMs !== undefined && idleIntervalMs > 3600000) {
+    if (idleInterval && idleInterval > Hours.one) {
         throw new ImplementationError("Session Idle Interval must be less than 1 hour");
     }
-    if (activeIntervalMs !== undefined && activeIntervalMs > 3600000) {
+    if (activeInterval && activeInterval > Hours.one) {
         throw new ImplementationError("Session Active Interval must be less than 1 hour");
     }
-    if (activeThresholdMs !== undefined && activeThresholdMs > 65535) {
+    if (activeThreshold && activeThreshold > Seconds(65535)) {
         throw new ImplementationError("Session Active Threshold must be less than 65535 seconds");
     }
 
@@ -50,8 +50,8 @@ export function SessionIntervals(intervals?: Partial<SessionIntervals>): Session
 
 export namespace SessionIntervals {
     export const defaults = {
-        idleIntervalMs: 500,
-        activeIntervalMs: 300,
-        activeThresholdMs: 4000,
+        idleInterval: Millis(500),
+        activeInterval: Millis(300),
+        activeThreshold: Seconds(4),
     };
 }