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

package/src/peer/ControllerCommissioningFlow.ts

@@ -15,10 +15,17 @@ import {
     Bytes,
     ChannelType,
     Diagnostic,
+    Duration,
+    Instant,
     Logger,
     MatterError,
+    Millis,
+    Minutes,
     repackErrorAs,
+    Seconds,
     Time,
+    Timespan,
+    Timestamp,
     UnexpectedDataError,
 } from "#general";
 import {
@@ -178,7 +185,7 @@ export class OperativeConnectionFailedError extends CommissioningError {}
 /** Error that throws when Commissioning fails but a process can be continued. */
 class RecoverableCommissioningError extends CommissioningError {}
 
-const DEFAULT_FAILSAFE_TIME_S = 60;
+const DEFAULT_FAILSAFE_TIME = Minutes.one;
 
 /**
  * Class to abstract the Device commission flow in a step wise way as defined in Specs. The specs are not 100%
@@ -195,12 +202,12 @@ export class ControllerCommissioningFlow {
     protected readonly commissioningSteps = new Array<CommissioningStep>();
     protected readonly commissioningStepResults = new Map<string, CommissioningStepResult>();
     readonly #clusterClients = new Map<ClusterId, ClusterClientObj>();
-    #commissioningStartedTime: number | undefined;
-    #commissioningExpiryTime: number | undefined;
-    #currentFailSafeEndTime: number | undefined;
+    #commissioningStartedTime: Timestamp | undefined;
+    #commissioningExpiryTime: Timestamp | undefined;
+    #currentFailSafeEndTime: Timestamp | undefined;
     protected lastBreadcrumb = 1;
     protected collectedCommissioningData: CollectedCommissioningData = {};
-    #defaultFailSafeTimeS = DEFAULT_FAILSAFE_TIME_S;
+    #defaultFailSafeTime = DEFAULT_FAILSAFE_TIME;
 
     constructor(
         /** InteractionClient for the initiated PASE session */
@@ -252,7 +259,7 @@ export class ControllerCommissioningFlow {
                 this.#setCommissioningStepResult(step, result);
 
                 if (this.#currentFailSafeEndTime !== undefined) {
-                    if (this.#commissioningExpiryTime !== undefined && Time.nowMs() > this.#commissioningExpiryTime) {
+                    if (this.#commissioningExpiryTime !== undefined && Time.nowMs > this.#commissioningExpiryTime) {
                         logger.error(
                             `Commissioning step ${step.stepNumber}.${step.subStepNumber}: ${step.name} succeeded, but commissioning took too long in general!`,
                         );
@@ -262,13 +269,14 @@ export class ControllerCommissioningFlow {
                             `Commissioning time exceeds the maximum timeframe${maxTimeS ? ` of ${maxTimeS}s` : ""}`,
                         );
                     }
+
                     /**
                      * 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
                      * command (see Section 11.9.6.2, “ArmFailSafe Command”)
                      */
-                    const timeLeft = Math.floor((this.#currentFailSafeEndTime - Time.nowMs()) / 1000);
-                    if (timeLeft < this.#defaultFailSafeTimeS / 2) {
+                    const timeLeft = Timespan(Time.nowMs, this.#currentFailSafeEndTime).duration;
+                    if (timeLeft < this.#defaultFailSafeTime / 2) {
                         logger.info(
                             `After Commissioning step ${step.stepNumber}.${step.subStepNumber}: ${
                                 step.name
@@ -595,45 +603,46 @@ export class ControllerCommissioningFlow {
      * reading BasicCommissioningInfo attribute (see Section 11.10.5.2, “BasicCommissioningInfo
      * Attribute”) prior to invoking the ArmFailSafe command.
      */
-    async #armFailsafe(timeS?: number) {
+    async #armFailsafe(time?: Duration) {
         const client = this.#getClusterClient(GeneralCommissioning.Cluster);
         if (this.collectedCommissioningData.basicCommissioningInfo === undefined) {
             const basicCommissioningInfo = await client.getBasicCommissioningInfoAttribute();
             this.collectedCommissioningData.basicCommissioningInfo = basicCommissioningInfo;
-            this.#defaultFailSafeTimeS = basicCommissioningInfo.failSafeExpiryLengthSeconds;
-            this.#commissioningStartedTime = Time.nowMs();
-            this.#commissioningExpiryTime =
-                this.#commissioningStartedTime + basicCommissioningInfo.maxCumulativeFailsafeSeconds * 1000;
+            this.#defaultFailSafeTime = Seconds(basicCommissioningInfo.failSafeExpiryLengthSeconds);
+            this.#commissioningStartedTime = Time.nowMs;
+            this.#commissioningExpiryTime = Timestamp(
+                this.#commissioningStartedTime + Seconds(basicCommissioningInfo.maxCumulativeFailsafeSeconds),
+            );
         }
-        const expiryLengthSeconds = timeS ?? this.#defaultFailSafeTimeS;
+        const expiryLength = time ?? this.#defaultFailSafeTime;
         this.#ensureGeneralCommissioningSuccess(
             "armFailSafe",
             await client.armFailSafe({
                 breadcrumb: this.lastBreadcrumb,
-                expiryLengthSeconds,
+                expiryLengthSeconds: Seconds.of(expiryLength),
             }),
         );
-        this.#currentFailSafeEndTime = Time.nowMs() + expiryLengthSeconds * 1000;
+        this.#currentFailSafeEndTime = Timestamp(Time.nowMs + expiryLength);
         return {
             code: CommissioningStepResultCode.Success,
             breadcrumb: this.lastBreadcrumb,
         };
     }
 
-    get #failSafeTimeLeftS() {
+    get #failSafeTimeLeft() {
         if (this.#currentFailSafeEndTime === undefined) {
-            return 0;
+            return Instant;
         }
-        return Math.max(0, Math.ceil((this.#currentFailSafeEndTime - Time.nowMs()) / 1000));
+        return Duration.max(Timespan(Time.nowMs, this.#currentFailSafeEndTime).duration, 0);
     }
 
-    async #ensureFailsafeTimerForS(maxProcessingTime: number) {
-        const minFailsafeTimeS = this.interactionClient.maximumPeerResponseTimeMs(maxProcessingTime);
+    async #ensureFailsafeTimerFor(maxProcessingTime: Duration) {
+        const minFailsafeTime = this.interactionClient.maximumPeerResponseTime(maxProcessingTime);
 
-        const timeLeft = this.#failSafeTimeLeftS;
-        if (timeLeft < minFailsafeTimeS) {
-            logger.debug(`Failsafe timer has only ${timeLeft}s left, re-arming for at least ${minFailsafeTimeS}s`);
-            await this.#armFailsafe(Math.max(minFailsafeTimeS, this.#defaultFailSafeTimeS));
+        const timeLeft = this.#failSafeTimeLeft;
+        if (timeLeft < minFailsafeTime) {
+            logger.debug(`Failsafe timer has only ${timeLeft}s left, re-arming for at least ${minFailsafeTime}`);
+            await this.#armFailsafe(Duration.max(minFailsafeTime, this.#defaultFailSafeTime));
         } else {
             logger.debug(`Failsafe timer is already set for at least ${timeLeft}s`);
         }
@@ -1019,8 +1028,8 @@ export class ControllerCommissioningFlow {
 
         // Only Scan when the device supports concurrent connections
         if (this.collectedCommissioningData.supportsConcurrentConnection !== false) {
-            const scanMaxTimeSeconds = await networkCommissioningClusterClient.getScanMaxTimeSecondsAttribute();
-            await this.#ensureFailsafeTimerForS(scanMaxTimeSeconds);
+            const scanMaxTime = Seconds(await networkCommissioningClusterClient.getScanMaxTimeSecondsAttribute());
+            await this.#ensureFailsafeTimerFor(scanMaxTime);
 
             const { networkingStatus, wiFiScanResults, debugText } =
                 await networkCommissioningClusterClient.scanNetworks(
@@ -1028,7 +1037,7 @@ export class ControllerCommissioningFlow {
                         ssid,
                         breadcrumb: this.lastBreadcrumb++,
                     },
-                    { expectedProcessingTimeMs: scanMaxTimeSeconds * 1000 },
+                    { expectedProcessingTime: scanMaxTime },
                 );
             if (networkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
                 throw new WifiNetworkSetupFailedError(`Commissionee failed to scan for WiFi networks: ${debugText}`);
@@ -1080,15 +1089,15 @@ export class ControllerCommissioningFlow {
             };
         }
 
-        const connectMaxTimeSeconds = await networkCommissioningClusterClient.getConnectMaxTimeSecondsAttribute();
-        await this.#ensureFailsafeTimerForS(connectMaxTimeSeconds);
+        const connectMaxTime = Seconds(await networkCommissioningClusterClient.getConnectMaxTimeSecondsAttribute());
+        await this.#ensureFailsafeTimerFor(connectMaxTime);
 
         const connectResult = await networkCommissioningClusterClient.connectNetwork(
             {
                 networkId: networkId,
                 breadcrumb: this.lastBreadcrumb++,
             },
-            { expectedProcessingTimeMs: connectMaxTimeSeconds * 1000 },
+            { expectedProcessingTime: connectMaxTime },
         );
 
         if (connectResult.networkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
@@ -1164,13 +1173,13 @@ export class ControllerCommissioningFlow {
 
         // Only Scan when the device supports concurrent connections
         if (this.collectedCommissioningData.supportsConcurrentConnection !== false) {
-            const scanMaxTimeSeconds = await networkCommissioningClusterClient.getScanMaxTimeSecondsAttribute();
-            await this.#ensureFailsafeTimerForS(scanMaxTimeSeconds);
+            const scanMaxTime = Seconds(await networkCommissioningClusterClient.getScanMaxTimeSecondsAttribute());
+            await this.#ensureFailsafeTimerFor(scanMaxTime);
 
             const { networkingStatus, threadScanResults, debugText } =
                 await networkCommissioningClusterClient.scanNetworks(
                     { breadcrumb: this.lastBreadcrumb++ },
-                    { expectedProcessingTimeMs: scanMaxTimeSeconds * 1000 },
+                    { expectedProcessingTime: scanMaxTime },
                 );
             if (networkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
                 throw new ThreadNetworkSetupFailedError(
@@ -1237,15 +1246,15 @@ export class ControllerCommissioningFlow {
             };
         }
 
-        const connectMaxTimeSeconds = await networkCommissioningClusterClient.getConnectMaxTimeSecondsAttribute();
-        await this.#ensureFailsafeTimerForS(connectMaxTimeSeconds);
+        const connectMaxTime = Seconds(await networkCommissioningClusterClient.getConnectMaxTimeSecondsAttribute());
+        await this.#ensureFailsafeTimerFor(connectMaxTime);
 
         const connectResult = await networkCommissioningClusterClient.connectNetwork(
             {
                 networkId: networkId,
                 breadcrumb: this.lastBreadcrumb++,
             },
-            { expectedProcessingTimeMs: connectMaxTimeSeconds * 1000 },
+            { expectedProcessingTime: connectMaxTime },
         );
 
         if (connectResult.networkingStatus !== NetworkCommissioning.NetworkCommissioningStatus.Success) {
@@ -1284,9 +1293,9 @@ export class ControllerCommissioningFlow {
         // TODO: Check whats needed for non-concurrent commissioning flows (maybe arm initially longer?)
         const reArmFailsafeInterval = Time.getPeriodicTimer(
             "Re-Arm Failsafe during reconnect",
-            (this.#defaultFailSafeTimeS / 2) * 1000,
+            Millis(this.#defaultFailSafeTime / 2),
             () => {
-                const now = Time.nowMs();
+                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`,

package/src/peer/ControllerDiscovery.ts

@@ -4,7 +4,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { anyPromise, ClassExtends, Diagnostic, Logger, NoResponseTimeoutError, serverAddressToString } from "#general";
+import {
+    anyPromise,
+    ClassExtends,
+    Diagnostic,
+    Duration,
+    Logger,
+    NoResponseTimeoutError,
+    Seconds,
+    ServerAddress,
+} from "#general";
 import { CommissionableDeviceDiscoveryFailedError } from "#peer/ControllerCommissioningFlow.js";
 import { NodeId } from "#types";
 import {
@@ -38,14 +47,14 @@ export class ControllerDiscovery {
     static async discoverDeviceAddressesByIdentifier(
         scanners: Array<Scanner>,
         identifier: CommissionableDeviceIdentifiers,
-        timeoutSeconds = 30,
+        timeout = Seconds(30),
     ): Promise<CommissionableDevice[]> {
         logger.info(`Start Discovering devices using identifier ${Diagnostic.json(identifier)} ...`);
 
         const scanResults = scanners.map(async scanner => {
             const foundDevices = await scanner.findCommissionableDevices(
                 identifier,
-                timeoutSeconds,
+                timeout,
                 scanner.type === "ble", // Force rediscovery for BLE
             );
             logger.info(`Found ${foundDevices.length} devices using identifier ${Diagnostic.json(identifier)}`);
@@ -73,7 +82,7 @@ export class ControllerDiscovery {
 
     static async discoverCommissionableDevices(
         scanners: Array<Scanner>,
-        timeoutSeconds: number,
+        timeout: Duration,
         identifier: CommissionableDeviceIdentifiers = {},
         discoveredCallback?: (device: CommissionableDevice) => void,
     ): Promise<CommissionableDevice[]> {
@@ -90,7 +99,7 @@ export class ControllerDiscovery {
                             discoveredCallback?.(device);
                         }
                     },
-                    timeoutSeconds,
+                    timeout,
                 );
             }),
         );
@@ -118,15 +127,10 @@ export class ControllerDiscovery {
         fabric: Fabric,
         peerNodeId: NodeId,
         scanner: MdnsClient,
-        timeoutSeconds?: number,
+        timeout?: Duration,
         ignoreExistingRecords?: boolean,
     ): Promise<OperationalDevice> {
-        const foundDevice = await scanner.findOperationalDevice(
-            fabric,
-            peerNodeId,
-            timeoutSeconds,
-            ignoreExistingRecords,
-        );
+        const foundDevice = await scanner.findOperationalDevice(fabric, peerNodeId, timeout, ignoreExistingRecords);
         if (foundDevice === undefined) {
             throw new DiscoveryError(
                 "The operational device cannot be found on the network. Please make sure it is online.",
@@ -160,7 +164,7 @@ export class ControllerDiscovery {
             address: AddressTypeFromDevice<DD>,
             device?: DD,
         ): Promise<{ result: T; resultAddress: AddressTypeFromDevice<DD>; resultDevice?: DD } | undefined> => {
-            const serverKey = serverAddressToString(address);
+            const serverKey = ServerAddress.urlFor(address);
 
             logger.debug(`Try to communicate with ${serverKey} ...`);
             try {
@@ -177,13 +181,13 @@ export class ControllerDiscovery {
         const addresses = new Map<string, { address: AddressTypeFromDevice<DD>; device?: DD }>();
 
         devices.forEach(device =>
-            device.addresses.forEach(address => addresses.set(serverAddressToString(address), { address, device })),
+            device.addresses.forEach(address => addresses.set(ServerAddress.urlFor(address), { address, device })),
         );
         const triedAddresses = new Set<string>();
 
         if (lastKnownAddress !== undefined) {
-            const knownKey = serverAddressToString(lastKnownAddress);
-            const knownDevice = addresses.has(serverAddressToString(lastKnownAddress))
+            const knownKey = ServerAddress.urlFor(lastKnownAddress);
+            const knownDevice = addresses.has(ServerAddress.urlFor(lastKnownAddress))
                 ? addresses.get(knownKey)?.device
                 : undefined;
             addresses.delete(knownKey);
@@ -203,7 +207,7 @@ export class ControllerDiscovery {
 
             let triedOne = false;
             for (const { address, device } of addresses.values()) {
-                const serverKey = serverAddressToString(address);
+                const serverKey = ServerAddress.urlFor(address);
                 if (triedAddresses.has(serverKey)) continue;
                 triedAddresses.add(serverKey);
 
@@ -224,7 +228,7 @@ export class ControllerDiscovery {
             if (triedOne) {
                 (await updateDevicesFunc()).forEach(device =>
                     device.addresses.forEach(address =>
-                        addresses.set(serverAddressToString(address), { address, device }),
+                        addresses.set(ServerAddress.urlFor(address), { address, device }),
                     ),
                 ); // Update list and add new
             } else {

package/src/peer/InteractionQueue.ts

@@ -4,14 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Environment, Environmental, PromiseQueue } from "#general";
+import { Environment, Environmental, Millis, PromiseQueue } from "#general";
 
 const CONCURRENT_QUEUED_INTERACTIONS = 4;
-const INTERACTION_QUEUE_DELAY_MS = 100;
+const INTERACTION_QUEUE_DELAY = Millis(100);
 
 export class InteractionQueue extends PromiseQueue {
     constructor() {
-        super(CONCURRENT_QUEUED_INTERACTIONS, INTERACTION_QUEUE_DELAY_MS);
+        super(CONCURRENT_QUEUED_INTERACTIONS, INTERACTION_QUEUE_DELAY);
     }
 
     static [Environmental.create](env: Environment) {

package/src/peer/PeerSet.ts

@@ -12,6 +12,7 @@ import {
     ChannelType,
     Construction,
     createPromise,
+    Duration,
     Environment,
     Environmental,
     ImmutableSet,
@@ -20,11 +21,13 @@ import {
     isIPv6,
     Logger,
     MatterError,
+    Minutes,
     NetInterfaceSet,
     NoResponseTimeoutError,
     ObservableSet,
+    Seconds,
+    ServerAddress,
     ServerAddressIp,
-    serverAddressToString,
     STANDARD_MATTER_PORT,
     Time,
     Timer,
@@ -50,8 +53,8 @@ import { PeerAddressStore, PeerDataStore } from "./PeerAddressStore.js";
 
 const logger = Logger.get("PeerSet");
 
-const RECONNECTION_POLLING_INTERVAL_MS = 600_000; // 10 minutes
-const RETRANSMISSION_DISCOVERY_TIMEOUT_S = 5;
+const RECONNECTION_POLLING_INTERVAL = Minutes(10);
+const RETRANSMISSION_DISCOVERY_TIMEOUT = Seconds(5);
 
 /**
  * Types of discovery that may be performed when connecting operationally.
@@ -78,7 +81,7 @@ export class UnknownNodeError extends MatterError {}
  */
 export interface DiscoveryOptions {
     discoveryType?: NodeDiscoveryType;
-    timeoutSeconds?: number;
+    timeout?: Duration;
     discoveryData?: DiscoveryData;
 }
 
@@ -333,7 +336,10 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
                 await this.#sessions.removeAllSessionsForNode(address);
                 throw new RetransmissionLimitReachedError(`No operational address found for ${PeerAddress(address)}`);
             }
-            if ((await this.#reconnectKnownAddress(address, operationalAddress, discoveryData, 2_000)) === undefined) {
+            if (
+                (await this.#reconnectKnownAddress(address, operationalAddress, discoveryData, Seconds(2))) ===
+                undefined
+            ) {
                 throw new RetransmissionLimitReachedError(`${PeerAddress(address)} is not reachable.`);
             }
         });
@@ -438,10 +444,10 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         address = PeerAddress(address);
         const {
             discoveryType: requestedDiscoveryType = NodeDiscoveryType.FullDiscovery,
-            timeoutSeconds,
+            timeout,
             discoveryData = this.#peersByAddress.get(address)?.discoveryData,
         } = discoveryOptions;
-        if (timeoutSeconds !== undefined && requestedDiscoveryType !== NodeDiscoveryType.TimedDiscovery) {
+        if (timeout !== undefined && requestedDiscoveryType !== NodeDiscoveryType.TimedDiscovery) {
             throw new ImplementationError("Cannot set timeout without timed discovery.");
         }
         if (requestedDiscoveryType === NodeDiscoveryType.RetransmissionDiscovery) {
@@ -480,7 +486,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
                 operationalAddress,
                 discoveryData,
                 // When we use a timeout for discovery also use this for reconnecting to the node
-                timeoutSeconds ? timeoutSeconds * 1000 : undefined,
+                timeout,
             );
             if (directReconnection !== undefined) {
                 return directReconnection;
@@ -515,14 +521,14 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
                 const { promise, resolver, rejecter } = createPromise<MessageChannel>();
 
                 logger.debug(
-                    `Starting reconnection polling for ${serverAddressToString(lastOperationalAddress)} (Interval ${RECONNECTION_POLLING_INTERVAL_MS / 1000}s)`,
+                    `Starting reconnection polling for ${ServerAddress.urlFor(lastOperationalAddress)} (interval ${Duration.format(RECONNECTION_POLLING_INTERVAL)})`,
                 );
                 reconnectionPollingTimer = Time.getPeriodicTimer(
                     "Controller reconnect",
-                    RECONNECTION_POLLING_INTERVAL_MS,
+                    RECONNECTION_POLLING_INTERVAL,
                     async () => {
                         try {
-                            logger.debug(`Polling for device at ${serverAddressToString(lastOperationalAddress)} ...`);
+                            logger.debug(`Polling for device at ${ServerAddress.urlFor(lastOperationalAddress)} ...`);
                             const result = await this.#reconnectKnownAddress(
                                 address,
                                 lastOperationalAddress,
@@ -565,8 +571,8 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
                 this.#sessions.fabricFor(address),
                 address.nodeId,
                 mdnsScanner,
-                timeoutSeconds,
-                timeoutSeconds === undefined,
+                timeout,
+                timeout === undefined,
             );
             const { stopTimerFunc } = this.#runningPeerDiscoveries.get(address) ?? {};
             stopTimerFunc?.();
@@ -611,21 +617,21 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         address: PeerAddress,
         operationalAddress: ServerAddressIp,
         discoveryData?: DiscoveryData,
-        expectedProcessingTimeMs?: number,
+        expectedProcessingTime?: Duration,
     ): Promise<MessageChannel | undefined> {
         address = PeerAddress(address);
 
         const { ip, port } = operationalAddress;
-        const startTime = Time.nowMs();
+        const startTime = Time.nowMs;
         try {
             logger.debug(
                 `Resuming connection to ${PeerAddress(address)} at ${ip}:${port}${
-                    expectedProcessingTimeMs !== undefined
-                        ? ` with expected processing time of ${expectedProcessingTimeMs}ms`
+                    expectedProcessingTime !== undefined
+                        ? ` with expected processing time of ${Duration.format(expectedProcessingTime)}`
                         : ""
                 }`,
             );
-            const channel = await this.#pair(address, operationalAddress, discoveryData, expectedProcessingTimeMs);
+            const channel = await this.#pair(address, operationalAddress, discoveryData, expectedProcessingTime);
             await this.#addOrUpdatePeer(address, operationalAddress);
             return channel;
         } catch (error) {
@@ -669,9 +675,9 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         address: PeerAddress,
         operationalServerAddress: ServerAddressIp,
         discoveryData?: DiscoveryData,
-        expectedProcessingTimeMs?: number,
+        expectedProcessingTime?: Duration,
     ) {
-        logger.debug(`Pair with ${address} at ${serverAddressToString(operationalServerAddress)}`);
+        logger.debug(`Pair with ${address} at ${ServerAddress.urlFor(operationalServerAddress)}`);
         const { ip, port } = operationalServerAddress;
         // Do CASE pairing
         const isIpv6Address = isIPv6(ip);
@@ -693,9 +699,9 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         const unsecureSession = this.#sessions.createInsecureSession({
             // Use the session parameters from MDNS announcements when available and rest is assumed to be fallbacks
             sessionParameters: {
-                idleIntervalMs: discoveryData?.SII ?? sessionParameters?.idleIntervalMs,
-                activeIntervalMs: discoveryData?.SAI ?? sessionParameters?.activeIntervalMs,
-                activeThresholdMs: discoveryData?.SAT ?? sessionParameters?.activeThresholdMs,
+                idleInterval: discoveryData?.SII ?? sessionParameters?.idleInterval,
+                activeInterval: discoveryData?.SAI ?? sessionParameters?.activeInterval,
+                activeThreshold: discoveryData?.SAT ?? sessionParameters?.activeThreshold,
             },
             isInitiator: true,
         });
@@ -704,7 +710,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
             const operationalSecureSession = await this.#doCasePair(
                 new MessageChannel(operationalChannel, unsecureSession),
                 address,
-                expectedProcessingTimeMs,
+                expectedProcessingTime,
             );
 
             const channel = new MessageChannel(operationalChannel, operationalSecureSession);
@@ -723,7 +729,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
     async #doCasePair(
         unsecureMessageChannel: MessageChannel,
         address: PeerAddress,
-        expectedProcessingTimeMs?: number,
+        expectedProcessingTime?: Duration,
     ): Promise<SecureSession> {
         const fabric = this.#sessions.fabricFor(address);
         let exchange: MessageExchange | undefined;
@@ -734,7 +740,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
                 exchange,
                 fabric,
                 address.nodeId,
-                expectedProcessingTimeMs,
+                expectedProcessingTime,
             );
 
             if (!resumed) {
@@ -755,7 +761,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
                         `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...`,
                     );
                     // An endless loop should not happen here, as the resumption record is deleted in the next step
-                    return await this.#doCasePair(unsecureMessageChannel, address, expectedProcessingTimeMs);
+                    return await this.#doCasePair(unsecureMessageChannel, address, expectedProcessingTime);
                 }
             }
             throw error;
@@ -844,7 +850,7 @@ export class PeerSet implements ImmutableSet<OperationalPeer>, ObservableSet<Ope
         this.#runningPeerDiscoveries.set(address, { type: NodeDiscoveryType.RetransmissionDiscovery });
         this.#scanners
             .scannerFor(ChannelType.UDP)
-            ?.findOperationalDevice(fabric, nodeId, RETRANSMISSION_DISCOVERY_TIMEOUT_S, true)
+            ?.findOperationalDevice(fabric, nodeId, RETRANSMISSION_DISCOVERY_TIMEOUT, true)
             .catch(error => {
                 logger.error(`Failed to discover ${address} after resubmission started.`, error);
             })

package/src/protocol/DeviceCommissioner.ts

@@ -24,7 +24,7 @@ import {
 import { SecureChannelProtocol } from "#securechannel/SecureChannelProtocol.js";
 import { PaseServer } from "#session/pase/PaseServer.js";
 import { SessionManager } from "#session/SessionManager.js";
-import { CommissioningOptions, STANDARD_COMMISSIONING_TIMEOUT_S, StatusCode, StatusResponseError } from "#types";
+import { CommissioningOptions, STANDARD_COMMISSIONING_TIMEOUT, StatusCode, StatusResponseError } from "#types";
 import type { ControllerCommissioner } from "../peer/ControllerCommissioner.js";
 import { DeviceAdvertiser } from "./DeviceAdvertiser.js";
 
@@ -161,7 +161,7 @@ export class DeviceCommissioner {
 
         this.#windowStatus = windowStatus;
         const commissioningConfig = this.#context.commissioningConfig.values;
-        const advertisementWindowS = commissioningConfig.advertisementWindowS ?? STANDARD_COMMISSIONING_TIMEOUT_S;
+        const advertisementWindowS = commissioningConfig.advertisementWindow ?? STANDARD_COMMISSIONING_TIMEOUT;
 
         const mode =
             windowStatus === AdministratorCommissioning.CommissioningWindowStatus.EnhancedWindowOpen

package/src/protocol/ExchangeManager.ts

@@ -26,7 +26,7 @@ import {
 import { PeerAddress } from "#peer/PeerAddress.js";
 import {
     ChannelNotConnectedError,
-    DEFAULT_EXPECTED_PROCESSING_TIME_MS,
+    DEFAULT_EXPECTED_PROCESSING_TIME,
     MessageChannel,
 } from "#protocol/MessageChannel.js";
 import { SecureChannelMessenger } from "#securechannel/SecureChannelMessenger.js";
@@ -412,12 +412,9 @@ export class ExchangeManager {
 
     calculateMaximumPeerResponseTimeMsFor(
         channel: MessageChannel,
-        expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS,
+        expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME,
     ) {
-        return channel.calculateMaximumPeerResponseTimeMs(
-            this.#sessionManager.sessionParameters,
-            expectedProcessingTimeMs,
-        );
+        return channel.calculateMaximumPeerResponseTime(this.#sessionManager.sessionParameters, expectedProcessingTime);
     }
 
     #messageExchangeContextFor(channel: MessageChannel): MessageExchangeContext {

package/src/protocol/ExchangeProvider.ts

@@ -3,13 +3,13 @@
  * Copyright 2022-2025 Matter.js Authors
  * SPDX-License-Identifier: Apache-2.0
  */
-import { ChannelType, Observable } from "#general";
+import { ChannelType, Duration, Observable } from "#general";
 import { PeerAddress } from "#peer/PeerAddress.js";
 import { ChannelManager } from "#protocol/ChannelManager.js";
 import { ExchangeManager } from "#protocol/ExchangeManager.js";
 import {
     ChannelNotConnectedError,
-    DEFAULT_EXPECTED_PROCESSING_TIME_MS,
+    DEFAULT_EXPECTED_PROCESSING_TIME,
     MessageChannel,
 } from "#protocol/MessageChannel.js";
 import { MessageExchange } from "#protocol/MessageExchange.js";
@@ -37,7 +37,7 @@ export abstract class ExchangeProvider {
         this.exchangeManager.addProtocolHandler(handler);
     }
 
-    abstract maximumPeerResponseTimeMs(expectedProcessingTimeMs?: number): number;
+    abstract maximumPeerResponseTime(expectedProcessingTime?: Duration): Duration;
     abstract initiateExchange(): Promise<MessageExchange>;
     abstract reconnectChannel(): Promise<boolean>;
     abstract session: Session;
@@ -72,8 +72,8 @@ export class DedicatedChannelExchangeProvider extends ExchangeProvider {
         return this.#channel.type;
     }
 
-    maximumPeerResponseTimeMs(expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS) {
-        return this.exchangeManager.calculateMaximumPeerResponseTimeMsFor(this.#channel, expectedProcessingTimeMs);
+    maximumPeerResponseTime(expectedProcessingTime = DEFAULT_EXPECTED_PROCESSING_TIME) {
+        return this.exchangeManager.calculateMaximumPeerResponseTimeMsFor(this.#channel, expectedProcessingTime);
     }
 }
 
@@ -136,7 +136,7 @@ export class ReconnectableExchangeProvider extends ExchangeProvider {
         return this.channelManager.getChannel(this.#address).type;
     }
 
-    maximumPeerResponseTimeMs(expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME_MS) {
+    maximumPeerResponseTime(expectedProcessingTimeMs = DEFAULT_EXPECTED_PROCESSING_TIME) {
         const channel = this.channelManager.getChannel(this.#address);
         if (!channel) {
             throw new ChannelNotConnectedError("Channel not connected");