@matter/protocol 0.16.0-alpha.0-20250809-ee8375bcb → 0.16.0-alpha.0-20250812-285b75d83

package/src/protocol/DeviceCommissioner.ts

@@ -4,12 +4,12 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { CommissioningMode } from "#advertisement/CommissioningMode.js";
+import { ServiceDescription } from "#advertisement/ServiceDescription.js";
 import { AdministratorCommissioning } from "#clusters/administrator-commissioning";
 import { FailsafeContext } from "#common/FailsafeContext.js";
-import { CommissioningMode } from "#common/InstanceBroadcaster.js";
 import { FabricManager } from "#fabric/FabricManager.js";
 import {
-    Diagnostic,
     Environment,
     Environmental,
     InternalError,
@@ -18,11 +18,13 @@ import {
     MatterFlowError,
     MaybePromise,
     ObserverGroup,
+    Time,
+    Timer,
 } from "#general";
 import { SecureChannelProtocol } from "#securechannel/SecureChannelProtocol.js";
 import { PaseServer } from "#session/pase/PaseServer.js";
 import { SessionManager } from "#session/SessionManager.js";
-import { CommissioningOptions, StatusCode, StatusResponseError } from "#types";
+import { CommissioningOptions, STANDARD_COMMISSIONING_TIMEOUT_S, StatusCode, StatusResponseError } from "#types";
 import type { ControllerCommissioner } from "../peer/ControllerCommissioner.js";
 import { DeviceAdvertiser } from "./DeviceAdvertiser.js";
 
@@ -59,52 +61,16 @@ export class DeviceCommissioner {
     #activeDiscriminator?: number;
     #activeCommissioningEndCallback?: () => MaybePromise;
     #observers = new ObserverGroup(this);
+    #commissioningTimeout?: Timer;
 
     constructor(context: DeviceCommissionerContext) {
         this.#context = context;
 
-        this.#observers.on(this.#context.advertiser.timedOut, this.endCommissioning);
-
-        // If a commissioning window is open then we re-announce this because it was ended as fabric got added
-        this.#observers.on(this.#context.fabrics.events.deleted, async () => {
-            // If a commissioning window is open, or we removed the last fabric, then we re-announce this
-            // because it was ended as fabric got added
-            if (
-                this.#context.fabrics.length === 0 ||
-                this.#windowStatus !== AdministratorCommissioning.CommissioningWindowStatus.WindowNotOpen
-            ) {
-                this.reactivateAdvertiser();
-            }
-        });
-
-        // No fabric paired yet, so announce as "ready for commissioning"
-        this.#observers.on(this.#context.advertiser.operationalModeEnded, this.allowBasicCommissioning);
-
         // Cancel commissioning when there are too many PASE errors
         this.#observers.on(this.#context.secureChannelProtocol.tooManyPaseErrors, async () => {
             logger.info("Maximum number of PASE pairing errors reached, canceling commissioning");
             await this.endCommissioning();
         });
-
-        this.#observers.on(this.#context.sessions.sessions.deleted, session => {
-            const currentFabricIndex = session.fabric?.fabricIndex;
-
-            // Verify if the session associated fabric still exists
-            const existingSessionFabric =
-                currentFabricIndex === undefined
-                    ? undefined
-                    : this.#context.fabrics.findByIndex(currentFabricIndex)?.fabricIndex;
-
-            // When a session closes, announce existing fabrics again so that controller can detect the device again.
-            // When session was closed and no fabric exist anymore then this is triggering a factory reset in upper
-            // layer and it would be not good to announce a commissionable device and then reset that again with the
-            // factory reset
-            if (this.#context.fabrics.length > 0 || session.isPase || !existingSessionFabric) {
-                this.#context.advertiser
-                    .startAdvertising()
-                    .catch(error => logger.warn(`Error while announcing`, error));
-            }
-        });
     }
 
     static [Environmental.create](env: Environment) {
@@ -131,12 +97,12 @@ export class DeviceCommissioner {
     ) {
         if (this.#windowStatus === AdministratorCommissioning.CommissioningWindowStatus.BasicWindowOpen) {
             throw new MatterFlowError(
-                "Basic commissioning window is already open! Cannot set Enhanced commissioning mode.",
+                "Basic commissioning window is already open! Cannot set enhanced commissioning mode.",
             );
         }
 
         this.#context.secureChannelProtocol.setPaseCommissioner(paseServer);
-        await this.#becomeCommissionable(
+        this.#becomeCommissionable(
             AdministratorCommissioning.CommissioningWindowStatus.EnhancedWindowOpen,
             commissioningEndCallback,
             discriminator,
@@ -146,7 +112,7 @@ export class DeviceCommissioner {
     async allowBasicCommissioning(commissioningEndCallback?: () => MaybePromise) {
         if (this.#windowStatus === AdministratorCommissioning.CommissioningWindowStatus.EnhancedWindowOpen) {
             throw new MatterFlowError(
-                "Enhanced commissioning window is already open! Cannot set Basic commissioning mode.",
+                "Enhanced commissioning window is already open! Cannot set basic commissioning mode.",
             );
         }
 
@@ -157,7 +123,7 @@ export class DeviceCommissioner {
             }),
         );
 
-        await this.#becomeCommissionable(
+        this.#becomeCommissionable(
             AdministratorCommissioning.CommissioningWindowStatus.BasicWindowOpen,
             commissioningEndCallback,
         );
@@ -166,16 +132,6 @@ export class DeviceCommissioner {
     beginTimed(failsafeContext: FailsafeContext) {
         this.#failsafeContext = failsafeContext;
 
-        this.#context.fabrics.events.added.on(fabric => {
-            const fabrics = this.#context.fabrics.fabrics;
-            this.#context.advertiser
-                .advertiseFabrics(fabrics, true)
-                .catch(error =>
-                    logger.warn(`Error sending Fabric announcement for Index ${fabric.fabricIndex}`, error),
-                );
-            logger.info("Announce done", Diagnostic.dict({ fabric: fabric.fabricId, fabricIndex: fabric.fabricIndex }));
-        });
-
         failsafeContext.commissioned.on(async () => await this.endCommissioning());
 
         failsafeContext.construction.change.on(status => {
@@ -197,55 +153,79 @@ export class DeviceCommissioner {
         );
     }
 
-    reactivateAdvertiser() {
-        if (this.#windowStatus === AdministratorCommissioning.CommissioningWindowStatus.WindowNotOpen) {
-            return;
-        }
-        this.#enterCommissioningMode(this.#windowStatus, this.#activeDiscriminator).catch(error =>
-            logger.warn("Error sending announcement:", error),
-        );
-    }
-
-    async #enterCommissioningMode(
+    #enterCommissioningMode(
         windowStatus: AdministratorCommissioning.CommissioningWindowStatus,
         discriminator?: number,
     ) {
+        this.#cancelTimeout();
+
         this.#windowStatus = windowStatus;
         const commissioningConfig = this.#context.commissioningConfig.values;
-        await this.#context.advertiser.enterCommissioningMode(
+        const advertisementWindowS = commissioningConfig.advertisementWindowS ?? STANDARD_COMMISSIONING_TIMEOUT_S;
+
+        const mode =
             windowStatus === AdministratorCommissioning.CommissioningWindowStatus.EnhancedWindowOpen
                 ? CommissioningMode.Enhanced
-                : CommissioningMode.Basic,
-            {
+                : CommissioningMode.Basic;
+
+        this.#context.advertiser.enterCommissioningMode(
+            ServiceDescription.Commissionable({
                 ...commissioningConfig.productDescription,
+                mode,
                 discriminator: discriminator ?? commissioningConfig.discriminator,
-            },
+            }),
+        );
+
+        this.#commissioningTimeout = Time.getTimer(
+            "Commissioning timeout",
+            advertisementWindowS,
+            this.endCommissioning.bind(this),
         );
     }
 
-    async #becomeCommissionable(
-        windowStatus: AdministratorCommissioning.CommissioningWindowStatus,
+    #becomeCommissionable(
+        windowStatus:
+            | AdministratorCommissioning.CommissioningWindowStatus.EnhancedWindowOpen
+            | AdministratorCommissioning.CommissioningWindowStatus.BasicWindowOpen,
         activeCommissioningEndCallback?: () => MaybePromise,
         discriminator?: number,
     ) {
+        if (this.#windowStatus !== AdministratorCommissioning.CommissioningWindowStatus.WindowNotOpen) {
+            if (this.#windowStatus !== windowStatus) {
+                throw new InternalError(
+                    `Commissioning mode ${windowStatus} request but already in mode ${this.#windowStatus}`,
+                );
+            }
+
+            if (
+                this.#activeCommissioningEndCallback &&
+                this.#activeCommissioningEndCallback !== activeCommissioningEndCallback
+            ) {
+                throw new InternalError(`Already in commissioning mode with a different callback`);
+            }
+        }
+
         if (
             this.#windowStatus === windowStatus &&
             (discriminator === undefined || discriminator === this.#activeDiscriminator)
         ) {
-            // We want to re-announce
-            return this.reactivateAdvertiser();
+            this.#enterCommissioningMode(this.#windowStatus, this.#activeDiscriminator);
+            return;
         }
+
         if (this.#windowStatus !== AdministratorCommissioning.CommissioningWindowStatus.WindowNotOpen) {
             throw new InternalError(`Commissioning window already open with different mode (${this.#windowStatus})!`);
         }
+
         if (this.#activeCommissioningEndCallback !== undefined) {
             throw new InternalError("Commissioning window already open with different callback!");
         }
+
         this.#activeCommissioningEndCallback = activeCommissioningEndCallback;
         this.#activeDiscriminator = discriminator;
 
         // MDNS is sent in parallel
-        await this.#enterCommissioningMode(windowStatus, discriminator);
+        this.#enterCommissioningMode(windowStatus, discriminator);
     }
 
     async endCommissioning() {
@@ -253,7 +233,7 @@ export class DeviceCommissioner {
             return;
         }
 
-        logger.debug("Commissioning mode ended, stop announcements.");
+        this.#cancelTimeout();
 
         this.#context.secureChannelProtocol.removePaseCommissioner();
 
@@ -267,10 +247,11 @@ export class DeviceCommissioner {
 
         await this.#context.advertiser.exitCommissioningMode();
 
-        logger.info("All commissioning announcements stopped");
+        logger.debug("No longer commissioning");
     }
 
     async close() {
+        this.#cancelTimeout();
         this.#observers.close();
         await this.endCommissioning();
         if (this.#failsafeContext) {
@@ -278,4 +259,13 @@ export class DeviceCommissioner {
             this.#failsafeContext = undefined;
         }
     }
+
+    #cancelTimeout() {
+        if (!this.#commissioningTimeout) {
+            return;
+        }
+
+        this.#commissioningTimeout.stop();
+        this.#commissioningTimeout = undefined;
+    }
 }

package/src/protocol/ExchangeManager.ts

@@ -422,7 +422,7 @@ export class ExchangeManager {
         return {
             channel,
             localSessionParameters: this.#sessionManager.sessionParameters,
-            resubmissionStarted: () => this.#sessionManager.resubmissionStarted.emit(channel.session),
+            retry: number => this.#sessionManager.retry.emit(channel.session, number),
         };
     }
 

package/src/protocol/MessageExchange.ts

@@ -26,12 +26,8 @@ import {
     MRP,
 } from "#protocol/MessageChannel.js";
 import { GroupSession } from "#session/GroupSession.js";
-import {
-    SESSION_ACTIVE_INTERVAL_MS,
-    SESSION_ACTIVE_THRESHOLD_MS,
-    SESSION_IDLE_INTERVAL_MS,
-    SessionParameters,
-} from "#session/Session.js";
+import { SessionParameters } from "#session/Session.js";
+import { SessionIntervals } from "#session/SessionIntervals.js";
 import {
     GroupId,
     NodeId,
@@ -103,7 +99,7 @@ export const MATTER_MESSAGE_OVERHEAD = 26 + 12 + CRYPTO_AEAD_MIC_LENGTH_BYTES;
  */
 export interface MessageExchangeContext {
     channel: MessageChannel;
-    resubmissionStarted(): void;
+    retry(number: number): void;
     localSessionParameters: SessionParameters;
 }
 
@@ -191,10 +187,10 @@ export class MessageExchange {
         this.#exchangeId = exchangeId;
         this.#protocolId = protocolId;
 
-        const { activeIntervalMs, idleIntervalMs, activeThresholdMs } = session.parameters;
-        this.#activeIntervalMs = activeIntervalMs ?? SESSION_ACTIVE_INTERVAL_MS;
-        this.#idleIntervalMs = idleIntervalMs ?? SESSION_IDLE_INTERVAL_MS;
-        this.#activeThresholdMs = activeThresholdMs ?? SESSION_ACTIVE_THRESHOLD_MS;
+        const { activeIntervalMs, idleIntervalMs, activeThresholdMs } = SessionIntervals(session.parameters);
+        this.#activeIntervalMs = activeIntervalMs;
+        this.#idleIntervalMs = idleIntervalMs;
+        this.#activeThresholdMs = activeThresholdMs;
 
         this.#used = !isInitiator; // If we are the initiator then exchange was not used yet, so track it
 
@@ -534,9 +530,7 @@ export class MessageExchange {
 
         this.session.notifyActivity(false);
 
-        if (this.#retransmissionCounter === 1) {
-            this.context.resubmissionStarted();
-        }
+        this.context.retry(this.#retransmissionCounter);
         const resubmissionBackoffTime = this.channel.getMrpResubmissionBackOffTime(this.#retransmissionCounter);
         logger.debug(
             `Resubmit message ${message.packetHeader.messageId} (retransmission attempt ${this.#retransmissionCounter}, backoff time ${resubmissionBackoffTime}ms))`,

package/src/protocol/ProtocolHandler.ts

@@ -8,8 +8,15 @@ import { Message } from "../codec/MessageCodec.js";
 import { MessageExchange } from "./MessageExchange.js";
 
 export interface ProtocolHandler {
+    /** Protocol ID that this handler implements */
     readonly id: number;
+
+    /** Indicates whether this protocol requires a secure session to be established before it can be used */
     readonly requiresSecureSession: boolean;
+
+    /** Called on a new exchange that uses this protocol. The message is the first message of the exchange. */
     onNewExchange(exchange: MessageExchange, message: Message): Promise<void>;
+
+    /** Called when the protocol handler is no longer needed and can clean up resources. */
     close(): Promise<void>;
 }

package/src/protocol/ProtocolStatusMessage.ts

@@ -5,33 +5,41 @@
  */
 
 import { DataReader, DataWriter, Endian } from "#general";
-import { GeneralStatusCode, Schema } from "#types";
+import { GeneralStatusCode, Schema, VendorId } from "#types";
 
 export type ProtocolStatusMessage<T> = {
     generalStatus: GeneralStatusCode;
     protocolId: number;
+    vendorId: VendorId;
     protocolStatus: T;
     protocolData?: Uint8Array;
 };
 
 export abstract class ProtocolStatusMessageSchema<T extends ProtocolStatusMessage<any>> extends Schema<T, Uint8Array> {
     #protocolId: number;
+    #vendorId: number;
     #protocolSpecificDataAllowed: boolean;
 
-    constructor(protocolId: number, protocolSpecificDataAllowed = true) {
+    constructor(protocol: number | { protocolId: number; vendorId: number }, protocolSpecificDataAllowed = true) {
         super();
-        this.#protocolId = protocolId;
+        if (typeof protocol === "number") {
+            this.#protocolId = protocol;
+            this.#vendorId = 0;
+        } else {
+            this.#protocolId = protocol.protocolId;
+            this.#vendorId = protocol.vendorId;
+        }
         this.#protocolSpecificDataAllowed = protocolSpecificDataAllowed;
     }
 
-    override encode(message: Omit<T, "protocolId">): Uint8Array {
-        return super.encode({ ...message, protocolId: this.#protocolId } as T);
+    override encode(message: Omit<T, "protocolId" | "vendorId">): Uint8Array {
+        return super.encode({ ...message, protocolId: this.#protocolId, vendorId: this.#vendorId } as T);
     }
 
-    encodeInternal({ generalStatus, protocolStatus, protocolId, protocolData }: T) {
+    encodeInternal({ generalStatus, protocolStatus, protocolId, protocolData, vendorId }: T) {
         const writer = new DataWriter(Endian.Little);
         writer.writeUInt16(generalStatus);
-        writer.writeUInt32(protocolId);
+        writer.writeUInt32((vendorId << 16) | protocolId);
         writer.writeUInt16(protocolStatus);
         if (this.#protocolSpecificDataAllowed && protocolData !== undefined && protocolData.length > 0) {
             writer.writeByteArray(protocolData);
@@ -42,10 +50,18 @@ export abstract class ProtocolStatusMessageSchema<T extends ProtocolStatusMessag
     decodeInternal(bytes: Uint8Array) {
         const reader = new DataReader(bytes, Endian.Little);
         const generalStatus = reader.readUInt16();
-        const protocolId = reader.readUInt32();
+        const vendorProtocolId = reader.readUInt32();
         const protocolStatus = reader.readUInt16();
-        const remainingBytes = reader.remainingBytesCount > 0 ? reader.remainingBytes : undefined;
+        const protocolData = reader.remainingBytesCount > 0 ? reader.remainingBytes : undefined;
 
-        return { generalStatus, protocolId, protocolStatus, remainingBytes } as unknown as T;
+        const protocolId = vendorProtocolId & 0xffff;
+        const vendorId = VendorId(vendorProtocolId >>> 16);
+        return {
+            generalStatus,
+            protocolId,
+            protocolStatus,
+            protocolData,
+            vendorId,
+        } as unknown as T;
     }
 }

package/src/securechannel/SecureChannelMessenger.ts

@@ -8,7 +8,7 @@ import { Diagnostic, MatterError, UnexpectedDataError } from "#general";
 import { GeneralStatusCode, SecureChannelStatusCode, SecureMessageType, TlvSchema } from "#types";
 import { Message } from "../codec/MessageCodec.js";
 import { ExchangeSendOptions, MessageExchange } from "../protocol/MessageExchange.js";
-import { TlvSecureChannelStatusMessage } from "./SecureChannelStatusMessageSchema.js";
+import { SecureChannelStatusMessage } from "./SecureChannelStatusMessageSchema.js";
 
 /** Error base Class for all errors related to the status response messages. */
 export class ChannelStatusResponseError extends MatterError {
@@ -150,7 +150,7 @@ export class SecureChannelMessenger {
     ) {
         await this.exchange.send(
             SecureMessageType.StatusReport,
-            TlvSecureChannelStatusMessage.encode({
+            SecureChannelStatusMessage.encode({
                 generalStatus,
                 protocolStatus,
             }),
@@ -171,7 +171,7 @@ export class SecureChannelMessenger {
         } = message;
         if (messageType !== SecureMessageType.StatusReport) return;
 
-        const { generalStatus, protocolId, protocolStatus } = TlvSecureChannelStatusMessage.decode(payload);
+        const { generalStatus, protocolId, protocolStatus } = SecureChannelStatusMessage.decode(payload);
         if (generalStatus !== GeneralStatusCode.Success) {
             throw new ChannelStatusResponseError(
                 `Received general error status for protocol ${protocolId}${logHint ? ` (${logHint})` : ""}`,

package/src/securechannel/SecureChannelProtocol.ts

@@ -23,7 +23,7 @@ import { SecureSession } from "../session/SecureSession.js";
 import { CaseServer } from "../session/case/CaseServer.js";
 import { MaximumPasePairingErrorsReachedError, PaseServer } from "../session/pase/PaseServer.js";
 import { ChannelStatusResponseError, SecureChannelMessenger } from "./SecureChannelMessenger.js";
-import { TlvSecureChannelStatusMessage } from "./SecureChannelStatusMessageSchema.js";
+import { SecureChannelStatusMessage } from "./SecureChannelStatusMessageSchema.js";
 
 const logger = Logger.get("SecureChannelProtocol");
 
@@ -62,7 +62,7 @@ export class StatusReportOnlySecureChannelProtocol implements ProtocolHandler {
             );
         }
 
-        const { generalStatus, protocolId, protocolStatus } = TlvSecureChannelStatusMessage.decode(payload);
+        const { generalStatus, protocolId, protocolStatus } = SecureChannelStatusMessage.decode(payload);
         if (generalStatus !== GeneralStatusCode.Success) {
             throw new ChannelStatusResponseError(
                 `Received general error status (${protocolId})`,

package/src/securechannel/SecureChannelStatusMessageSchema.ts

@@ -7,8 +7,8 @@
 import { ProtocolStatusMessage, ProtocolStatusMessageSchema } from "#protocol/ProtocolStatusMessage.js";
 import { SECURE_CHANNEL_PROTOCOL_ID, SecureChannelStatusCode } from "#types";
 
-export type SecureChannelStatusMessage = ProtocolStatusMessage<SecureChannelStatusCode>;
+export type SecureChannelStatus = ProtocolStatusMessage<SecureChannelStatusCode>;
 
-export class SecureChannelStatusMessageSchema extends ProtocolStatusMessageSchema<SecureChannelStatusMessage> {}
+export class SecureChannelStatusMessageSchema extends ProtocolStatusMessageSchema<SecureChannelStatus> {}
 
-export const TlvSecureChannelStatusMessage = new SecureChannelStatusMessageSchema(SECURE_CHANNEL_PROTOCOL_ID);
+export const SecureChannelStatusMessage = new SecureChannelStatusMessageSchema(SECURE_CHANNEL_PROTOCOL_ID);

package/src/session/NodeSession.ts

@@ -300,6 +300,10 @@ export class NodeSession extends SecureSession {
         return this.#peerNodeId;
     }
 
+    get hasAssociatedFabric() {
+        return this.#fabric !== undefined;
+    }
+
     get associatedFabric(): Fabric {
         if (this.#fabric === undefined) {
             throw new NoAssociatedFabricError(

package/src/session/Session.ts

@@ -4,30 +4,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { SupportedTransportsBitmap } from "#common/SupportedTransportsBitmap.js";
 import { AsyncObservable, DataWriter, Endian, InternalError, Time } from "#general";
 import { NodeId, TypeFromPartialBitSchema } from "#types";
 import { DecodedMessage, DecodedPacket, Message, Packet, SessionType } from "../codec/MessageCodec.js";
-import { SupportedTransportsBitmap } from "../common/Scanner.js";
 import { Fabric } from "../fabric/Fabric.js";
 import { MessageCounter } from "../protocol/MessageCounter.js";
 import { MessageReceptionState } from "../protocol/MessageReceptionState.js";
+import { SessionIntervals } from "./SessionIntervals.js";
 import { type SessionManager } from "./SessionManager.js";
 
-/**
- * Minimum amount of time between sender retries when the destination node is Active. This SHALL be greater than or
- * equal to the maximum amount of time a node may be non-responsive to incoming messages when Active.
- */
-export const SESSION_ACTIVE_INTERVAL_MS = 300;
-
-/**
- * Minimum amount of time between sender retries when the destination node is Idle. This SHALL be greater than or equal
- * to the maximum amount of time a node may be non-responsive to incoming messages when Idle.
- */
-export const SESSION_IDLE_INTERVAL_MS = 500;
-
-/** Minimum amount of time the node SHOULD stay active after network activity. */
-export const SESSION_ACTIVE_THRESHOLD_MS = 4000;
-
 /** Fallback value for Data Model Revision when not provided in Session parameters. We use Matter 1.2 as assumption. */
 export const FALLBACK_DATAMODEL_REVISION = 17;
 
@@ -48,29 +34,7 @@ export const FALLBACK_MAX_PATHS_PER_INVOKE = 1;
 
 export const FALLBACK_MAX_TCP_MESSAGE_SIZE = 64000;
 
-export interface SessionParameters {
-    /**
-     * Minimum amount of time between sender retries when the destination node is Idle.
-     * This SHALL be greater than or equal to the maximum amount of time a node may be
-     * non-responsive to incoming messages when Idle.
-     * Default: 500ms
-     */
-    idleIntervalMs: number;
-
-    /**
-     * Minimum amount of time between sender retries when the destination node is Active.
-     * This SHALL be greater than or equal to the maximum amount of time a node may be
-     * non-responsive to incoming messages when Active.
-     * Default: 300ms
-     */
-    activeIntervalMs: number;
-
-    /**
-     * Minimum amount of time the node SHOULD stay active after network activity.
-     * Default: 4000ms
-     */
-    activeThresholdMs: number;
-
+export interface SessionParameters extends SessionIntervals {
     /** Version of Data Model for the Session parameters side where it appears. */
     dataModelRevision: number;
 
@@ -136,9 +100,9 @@ export abstract class Session {
             messageCounter,
             messageReceptionState,
             sessionParameters: {
-                idleIntervalMs = SESSION_IDLE_INTERVAL_MS,
-                activeIntervalMs = SESSION_ACTIVE_INTERVAL_MS,
-                activeThresholdMs = SESSION_ACTIVE_THRESHOLD_MS,
+                idleIntervalMs = SessionIntervals.defaults.idleIntervalMs,
+                activeIntervalMs = SessionIntervals.defaults.activeIntervalMs,
+                activeThresholdMs = SessionIntervals.defaults.activeThresholdMs,
                 dataModelRevision = FALLBACK_DATAMODEL_REVISION,
                 interactionModelRevision = FALLBACK_INTERACTIONMODEL_REVISION,
                 specificationVersion = FALLBACK_SPECIFICATION_VERSION,

package/src/session/SessionIntervals.ts

@@ -0,0 +1,57 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ImplementationError } from "@matter/general";
+
+export interface SessionIntervals {
+    /**
+     * Minimum amount of time between sender retries when the destination node is idle. This SHALL be greater than or
+     * equal to the maximum amount of time a node may be non-responsive to incoming messages when idle.
+     *
+     * Default: 500ms
+     */
+    idleIntervalMs: number;
+
+    /**
+     * Minimum amount of time between sender retries when the destination node is active. This SHALL be greater than or
+     * equal to the maximum amount of time a node may be non-responsive to incoming messages when active.
+     *
+     * Default: 300ms
+     */
+    activeIntervalMs: number;
+
+    /**
+     * Minimum amount of time the node SHOULD stay active after network activity.
+     *
+     * Default: 4000ms
+     */
+    activeThresholdMs: number;
+}
+
+export function SessionIntervals(intervals?: Partial<SessionIntervals>): SessionIntervals {
+    const reified = { ...SessionIntervals.defaults, ...intervals };
+    const { idleIntervalMs, activeIntervalMs, activeThresholdMs } = reified;
+
+    if (idleIntervalMs !== undefined && idleIntervalMs > 3600000) {
+        throw new ImplementationError("Session Idle Interval must be less than 1 hour");
+    }
+    if (activeIntervalMs !== undefined && activeIntervalMs > 3600000) {
+        throw new ImplementationError("Session Active Interval must be less than 1 hour");
+    }
+    if (activeThresholdMs !== undefined && activeThresholdMs > 65535) {
+        throw new ImplementationError("Session Active Threshold must be less than 65535 seconds");
+    }
+
+    return reified;
+}
+
+export namespace SessionIntervals {
+    export const defaults = {
+        idleIntervalMs: 500,
+        activeIntervalMs: 300,
+        activeThresholdMs: 4000,
+    };
+}