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

package/src/mdns/MdnsClient.ts

@@ -14,15 +14,23 @@ import {
     DnsRecord,
     DnsRecordClass,
     DnsRecordType,
+    Duration,
+    Hours,
     ImplementationError,
+    Instant,
     InternalError,
     Lifespan,
     Logger,
+    Millis,
+    Minutes,
     ObserverGroup,
+    Seconds,
+    ServerAddress,
     ServerAddressIp,
     SrvRecordValue,
     Time,
     Timer,
+    Timespan,
     createPromise,
     isIPv6,
 } from "#general";
@@ -86,7 +94,7 @@ type StructuredDnsAnswers = {
 } & StructuredDnsAddressAnswers;
 
 /** The initial number of seconds between two announcements. MDNS specs require 1-2 seconds, so lets use the middle. */
-const START_ANNOUNCE_INTERVAL_SECONDS = 1.5;
+const START_ANNOUNCE_INTERVAL = Seconds(1.5);
 
 /**
  * Interface to add criteria for MDNS discovery a node is interested in
@@ -141,7 +149,7 @@ export class MdnsClient implements Scanner {
     >();
 
     #queryTimer?: Timer;
-    #nextAnnounceIntervalSeconds = START_ANNOUNCE_INTERVAL_SECONDS;
+    #nextAnnounceInterval = START_ANNOUNCE_INTERVAL;
     readonly #periodicTimer: Timer;
     #closing = false;
     readonly #socket: MdnsSocket;
@@ -158,7 +166,7 @@ export class MdnsClient implements Scanner {
     constructor(socket: MdnsSocket) {
         this.#socket = socket;
         this.#observers.on(this.#socket.receipt, this.#handleMessage.bind(this));
-        this.#periodicTimer = Time.getPeriodicTimer("Discovered node expiration", 60 * 1000 /* 1 mn */, () =>
+        this.#periodicTimer = Time.getPeriodicTimer("Discovered node expiration", Minutes.one, () =>
             this.#expire(),
         ).start();
 
@@ -230,8 +238,8 @@ export class MdnsClient implements Scanner {
         }
     }
 
-    #effectiveTTL(ttl: number) {
-        return Math.ceil(ttl * MDNS_EXPIRY_GRACE_PERIOD_FACTOR);
+    #effectiveTTL(ttl: Duration) {
+        return Millis(ttl * MDNS_EXPIRY_GRACE_PERIOD_FACTOR);
     }
 
     /**
@@ -250,16 +258,16 @@ export class MdnsClient implements Scanner {
             ),
         );
 
-        this.#queryTimer = Time.getTimer("MDNS discovery", this.#nextAnnounceIntervalSeconds * 1000, () =>
+        this.#queryTimer = Time.getTimer("MDNS discovery", this.#nextAnnounceInterval, () =>
             this.#sendQueries(),
         ).start();
 
         logger.debug(
-            `Sending ${queries.length} query records for ${this.#activeAnnounceQueries.size} queries with ${answers.length} known answers. Re-Announce in ${this.#nextAnnounceIntervalSeconds} seconds`,
+            `Sending ${queries.length} query records for ${this.#activeAnnounceQueries.size} queries with ${answers.length} known answers. Re-Announce in ${Duration.format(this.#nextAnnounceInterval)}`,
         );
 
-        const nextAnnounceInterval = this.#nextAnnounceIntervalSeconds * 2;
-        this.#nextAnnounceIntervalSeconds = Math.min(nextAnnounceInterval, 60 * 60 /* 1 hour */);
+        const nextAnnounceInterval = Millis(this.#nextAnnounceInterval * 2);
+        this.#nextAnnounceInterval = Duration.min(nextAnnounceInterval, Hours.one);
 
         await this.#socket.send({
             messageType: DnsMessageType.Query,
@@ -298,8 +306,8 @@ export class MdnsClient implements Scanner {
         this.#activeAnnounceQueries.set(queryId, { queries, answers });
         logger.debug(`Set ${queries.length} query records for query ${queryId}: ${Diagnostic.json(queries)}`);
         this.#queryTimer?.stop();
-        this.#nextAnnounceIntervalSeconds = START_ANNOUNCE_INTERVAL_SECONDS; // Reset query interval
-        this.#queryTimer = Time.getTimer("MDNS discovery", 0, () => this.#sendQueries()).start();
+        this.#nextAnnounceInterval = START_ANNOUNCE_INTERVAL; // Reset query interval
+        this.#queryTimer = Time.getTimer("MDNS discovery", Instant, () => this.#sendQueries()).start();
     }
 
     /**
@@ -322,7 +330,7 @@ export class MdnsClient implements Scanner {
         if (this.#activeAnnounceQueries.size === 0) {
             logger.debug(`Removing last query ${queryId} and stopping announce timer`);
             this.#queryTimer?.stop();
-            this.#nextAnnounceIntervalSeconds = START_ANNOUNCE_INTERVAL_SECONDS;
+            this.#nextAnnounceInterval = START_ANNOUNCE_INTERVAL;
         } else {
             logger.debug(`Removing query ${queryId}`);
         }
@@ -395,14 +403,14 @@ export class MdnsClient implements Scanner {
     async #registerWaiterPromise(
         queryId: string,
         commissionable: boolean,
-        timeoutSeconds?: number,
+        timeout?: Duration,
         resolveOnUpdatedRecords = true,
         cancelResolver?: (value: void) => void,
     ) {
         const { promise, resolver } = createPromise<void>();
         const timer =
-            timeoutSeconds !== undefined
-                ? Time.getTimer("MDNS timeout", timeoutSeconds * 1000, () => {
+            timeout !== undefined
+                ? Time.getTimer("MDNS timeout", timeout, () => {
                       cancelResolver?.();
                       this.#finishWaiter(queryId, true);
                   }).start()
@@ -415,7 +423,7 @@ export class MdnsClient implements Scanner {
         }
         logger.debug(
             `Registered waiter for query ${queryId} with ${
-                timeoutSeconds !== undefined ? `timeout ${timeoutSeconds} seconds` : "no timeout"
+                timeout !== undefined ? `timeout ${timeout}` : "no timeout"
             }${resolveOnUpdatedRecords ? "" : " (not resolving on updated records)"}`,
         );
         await promise;
@@ -482,7 +490,7 @@ export class MdnsClient implements Scanner {
     async findOperationalDevice(
         { operationalId }: Fabric,
         nodeId: NodeId,
-        timeoutSeconds?: number,
+        timeout?: Duration,
         ignoreExistingRecords = false,
     ): Promise<OperationalDevice | undefined> {
         if (this.#closing) {
@@ -492,7 +500,7 @@ export class MdnsClient implements Scanner {
 
         let storedDevice = ignoreExistingRecords ? undefined : this.#getOperationalDeviceRecords(deviceMatterQname);
         if (storedDevice === undefined) {
-            const promise = this.#registerWaiterPromise(deviceMatterQname, false, timeoutSeconds);
+            const promise = this.#registerWaiterPromise(deviceMatterQname, false, timeout);
 
             this.#setQueryRecords(deviceMatterQname, [
                 {
@@ -711,7 +719,7 @@ export class MdnsClient implements Scanner {
      */
     async findCommissionableDevices(
         identifier: CommissionableDeviceIdentifiers,
-        timeoutSeconds = 5,
+        timeout = Seconds(5),
         ignoreExistingRecords = false,
     ): Promise<CommissionableDevice[]> {
         let storedRecords = ignoreExistingRecords
@@ -719,7 +727,7 @@ export class MdnsClient implements Scanner {
             : this.#getCommissionableDeviceRecords(identifier).filter(({ addresses }) => addresses.length > 0);
         if (storedRecords.length === 0) {
             const queryId = this.#buildCommissionableQueryIdentifier(identifier);
-            const promise = this.#registerWaiterPromise(queryId, true, timeoutSeconds);
+            const promise = this.#registerWaiterPromise(queryId, true, timeout);
 
             this.#setQueryRecords(queryId, this.#getCommissionableQueryRecords(identifier));
 
@@ -737,12 +745,12 @@ export class MdnsClient implements Scanner {
     async findCommissionableDevicesContinuously(
         identifier: CommissionableDeviceIdentifiers,
         callback: (device: CommissionableDevice) => void,
-        timeoutSeconds?: number,
+        timeout?: Duration,
         cancelSignal?: Promise<void>,
     ): Promise<CommissionableDevice[]> {
         const discoveredDevices = new Set<string>();
 
-        const discoveryEndTime = timeoutSeconds ? Time.nowMs() + timeoutSeconds * 1000 : undefined;
+        const discoveryEndTime = timeout ? Time.nowMs + timeout : undefined;
         const queryId = this.#buildCommissionableQueryIdentifier(identifier);
         this.#setQueryRecords(queryId, this.#getCommissionableQueryRecords(identifier));
 
@@ -778,7 +786,7 @@ export class MdnsClient implements Scanner {
 
             let remainingTime;
             if (discoveryEndTime !== undefined) {
-                remainingTime = Math.ceil((discoveryEndTime - Time.nowMs()) / 1000);
+                remainingTime = Seconds.ceil(Timespan(Time.nowMs, discoveryEndTime).duration);
                 if (remainingTime <= 0) {
                     break;
                 }
@@ -810,7 +818,7 @@ export class MdnsClient implements Scanner {
     #structureAnswers(...answersList: DnsRecord<any>[][]): StructuredDnsAnswers {
         const structuredAnswers: StructuredDnsAnswers = {};
 
-        const discoveredAt = Time.nowMs();
+        const discoveredAt = Time.nowMs;
         answersList.forEach(answers =>
             answers.forEach(answer => {
                 const { name, recordType } = answer;
@@ -1055,7 +1063,7 @@ export class MdnsClient implements Scanner {
         answers: StructuredDnsAnswers[],
         target: string,
         netInterface: string,
-    ): { value: string; ttl: number }[] {
+    ): { value: string; ttl: Duration }[] {
         const ipRecords = new Array<AnyDnsRecordWithExpiry>();
         answers.forEach(answer => {
             if (answer.addressesV6?.[target]) {
@@ -1073,7 +1081,7 @@ export class MdnsClient implements Scanner {
         this.#registerIpRecords(ipRecords, netInterface); // Register for potential later usage
 
         // If an IP is included multiple times we only keep the latest record
-        const collectedIps = new Map<string, { value: string; ttl: number }>();
+        const collectedIps = new Map<string, { value: string; ttl: Duration }>();
         ipRecords.forEach(record => {
             const { value, ttl } = record as DnsRecord<string>;
             if (value.startsWith("fe80::")) {
@@ -1123,7 +1131,7 @@ export class MdnsClient implements Scanner {
 
     #handleOperationalTxtRecord(record: DnsRecord<any>, netInterface: string) {
         const { name: matterName, value, ttl } = record as DnsRecord<string[]>;
-        const discoveredAt = Time.nowMs();
+        const discoveredAt = Time.nowMs;
 
         // we got an expiry info, so we can remove the record if we know it already and are done
         if (ttl === 0) {
@@ -1151,19 +1159,16 @@ export class MdnsClient implements Scanner {
             device = {
                 ...device,
                 discoveredAt,
-                ttl: ttl * 1000,
+                ttl,
                 ...txtData,
             };
         } else {
-            logger.debug(
-                `Adding operational device ${matterName} in cache (interface ${netInterface}, ttl=${ttl}) with TXT data:`,
-                MdnsClient.discoveryDataDiagnostics(txtData),
-            );
+            logNewService(matterName, "operational", txtData);
             device = {
                 deviceIdentifier: matterName,
                 addresses: new Map<string, MatterServerRecordWithExpire>(),
                 discoveredAt,
-                ttl: ttl * 1000,
+                ttl,
                 ...txtData,
             };
         }
@@ -1203,12 +1208,12 @@ export class MdnsClient implements Scanner {
             return;
         }
 
-        const discoveredAt = Time.nowMs();
+        const discoveredAt = Time.nowMs;
         const device = this.#operationalDeviceRecords.get(matterName) ?? {
             deviceIdentifier: matterName,
             addresses: new Map<string, MatterServerRecordWithExpire>(),
             discoveredAt,
-            ttl: ttl * 1000,
+            ttl,
         };
         const ipsInitiallyEmpty = device.addresses.size === 0;
         const { addresses } = device;
@@ -1223,16 +1228,13 @@ export class MdnsClient implements Scanner {
                 }
                 const address = addresses.get(ip) ?? ({ ip, port, type: "udp" } as MatterServerRecordWithExpire);
                 address.discoveredAt = discoveredAt;
-                address.ttl = ttl * 1000;
+                address.ttl = ttl;
 
                 addresses.set(address.ip, address);
             }
             device.addresses = addresses;
             if (ipsInitiallyEmpty) {
-                logger.debug(
-                    `Added ${addresses.size} IPs for operational device ${matterName} to cache (interface ${netInterface}):`,
-                    ...MdnsClient.deviceAddressDiagnostics(addresses),
-                );
+                logNewAddresses(matterName, "operational", netInterface, addresses);
             }
             this.#operationalDeviceRecords.set(matterName, device);
         }
@@ -1305,10 +1307,7 @@ export class MdnsClient implements Scanner {
             if (storedRecord === undefined) {
                 queryMissingDataForInstances.add(name);
 
-                logger.debug(
-                    `Found commissionable device ${name} with data:`,
-                    MdnsClient.discoveryDataDiagnostics(parsedRecord),
-                );
+                logNewService(name, "commissionable", parsedRecord);
             } else {
                 parsedRecord.addresses = storedRecord.addresses;
             }
@@ -1346,8 +1345,8 @@ export class MdnsClient implements Scanner {
                     }
                     const matterServer =
                         storedRecord.addresses.get(ip) ?? ({ ip, port, type: "udp" } as MatterServerRecordWithExpire);
-                    matterServer.discoveredAt = Time.nowMs();
-                    matterServer.ttl = ttl * 1000;
+                    matterServer.discoveredAt = Time.nowMs;
+                    matterServer.ttl = ttl;
 
                     storedRecord.addresses.set(ip, matterServer);
                 }
@@ -1366,10 +1365,7 @@ export class MdnsClient implements Scanner {
                 );
                 this.#setQueryRecords(queryId, queries, answers);
             } else if (!recordAddressesKnown) {
-                logger.debug(
-                    `Added ${storedRecord.addresses.size} IPs for commissionable device ${record.name} to cache (interface ${netInterface}):`,
-                    ...MdnsClient.deviceAddressDiagnostics(storedRecord.addresses),
-                );
+                logNewAddresses(record.name, "commissionable", netInterface, storedRecord.addresses);
             }
             if (storedRecord.addresses.size === 0) continue;
 
@@ -1404,12 +1400,17 @@ export class MdnsClient implements Scanner {
             for (const item of value) {
                 const [key, value] = item.split("=");
                 if (key === undefined || value === undefined) continue;
-                if (["SII", "SAI", "SAT", "T", "D", "CM", "DT", "PH", "ICD"].includes(key)) {
+                if (["T", "D", "CM", "DT", "PH", "ICD"].includes(key)) {
                     const intValue = parseInt(value);
                     if (isNaN(intValue)) continue;
                     result[key] = intValue;
                 } else if (["VP", "DN", "RI", "PI"].includes(key)) {
                     result[key] = value;
+                } else if (["SII", "SAI", "SAT"].includes(key)) {
+                    const intValue = parseInt(value);
+                    if (isNaN(intValue)) continue;
+                    result[key] = intValue;
+                    result[key] = Millis(intValue);
                 }
             }
         }
@@ -1439,14 +1440,14 @@ export class MdnsClient implements Scanner {
         }
         return {
             addresses: new Map<string, MatterServerRecordWithExpire>(),
-            discoveredAt: Time.nowMs(),
-            ttl: ttl * 1000,
+            discoveredAt: Time.nowMs,
+            ttl,
             ...txtRecord,
         };
     }
 
     #expire() {
-        const now = Time.nowMs();
+        const now = Time.nowMs;
         [...this.#operationalDeviceRecords.entries()].forEach(([recordKey, { addresses, discoveredAt, ttl }]) => {
             const expires = discoveredAt + this.#effectiveTTL(ttl);
             if (now <= expires) {
@@ -1486,7 +1487,7 @@ export class MdnsClient implements Scanner {
             Object.keys(data.operational).forEach(recordType => {
                 const type = parseInt(recordType);
                 data.operational![type] = data.operational![type].filter(
-                    ({ discoveredAt, ttl }) => now < discoveredAt + this.#effectiveTTL(ttl * 1000),
+                    ({ discoveredAt, ttl }) => now < discoveredAt + this.#effectiveTTL(ttl),
                 );
                 if (data.operational![type].length === 0) {
                     delete data.operational![type];
@@ -1497,7 +1498,7 @@ export class MdnsClient implements Scanner {
             Object.keys(data.commissionable).forEach(recordType => {
                 const type = parseInt(recordType);
                 data.commissionable![type] = data.commissionable![type].filter(
-                    ({ discoveredAt, ttl }) => now < discoveredAt + this.#effectiveTTL(ttl * 1000),
+                    ({ discoveredAt, ttl }) => now < discoveredAt + this.#effectiveTTL(ttl),
                 );
                 if (data.commissionable![type].length === 0) {
                     delete data.commissionable![type];
@@ -1507,7 +1508,7 @@ export class MdnsClient implements Scanner {
         if (data.addressesV6) {
             Object.keys(data.addressesV6).forEach(name => {
                 for (const [ip, { discoveredAt, ttl }] of data.addressesV6![name].entries()) {
-                    if (now < discoveredAt + this.#effectiveTTL(ttl * 1000)) continue; // not expired yet
+                    if (now < discoveredAt + this.#effectiveTTL(ttl)) continue; // not expired yet
                     data.addressesV6![name].delete(ip);
                 }
                 if (data.addressesV6![name].size === 0) {
@@ -1518,7 +1519,7 @@ export class MdnsClient implements Scanner {
         if (data.addressesV4) {
             Object.keys(data.addressesV4).forEach(name => {
                 for (const [ip, { discoveredAt, ttl }] of data.addressesV4![name].entries()) {
-                    if (now < discoveredAt + this.#effectiveTTL(ttl * 1000)) continue; // not expired yet
+                    if (now < discoveredAt + this.#effectiveTTL(ttl)) continue; // not expired yet
                     data.addressesV4![name].delete(ip);
                 }
                 if (data.addressesV4![name].size === 0) {
@@ -1528,32 +1529,54 @@ export class MdnsClient implements Scanner {
         }
     }
 
-    static discoveryDataDiagnostics(data: DiscoveryData) {
-        return Diagnostic.dict(
-            {
-                SII: data.SII,
-                SAI: data.SAI,
-                SAT: data.SAT,
-                T: data.T,
-                DT: data.DT,
-                PH: data.PH,
-                ICD: data.ICD,
-                VP: data.VP,
-                DN: data.DN,
-                RI: data.RI,
-                PI: data.PI,
-            },
-            true,
-        );
+    static discoveryDataDiagnostics(data: DiscoveryData, kind?: string) {
+        return Diagnostic.dict({
+            kind,
+            SII: Duration.format(data.SII),
+            SAI: Duration.format(data.SAI),
+            SAT: Duration.format(data.SAT),
+            T: data.T,
+            DT: data.DT,
+            PH: data.PH,
+            ICD: data.ICD,
+            VP: data.VP,
+            DN: data.DN,
+            RI: data.RI,
+            PI: data.PI,
+        });
     }
 
     static deviceAddressDiagnostics(addresses: Map<string, MatterServerRecordWithExpire>) {
-        return Array.from(addresses.values()).map(address =>
-            Diagnostic.dict({
-                type: address.type,
-                ip: address.ip,
-                port: address.port,
-            }),
-        );
+        const diagnostic = Array<unknown>();
+        for (const address of addresses.values()) {
+            if (diagnostic.length) {
+                diagnostic.push(", ");
+            }
+            diagnostic.push(ServerAddress.diagnosticFor(address));
+        }
+        return Diagnostic.squash(...diagnostic);
     }
 }
+
+function logNewService(service: string, kind: string, data: DiscoveryData) {
+    logger.debug("Found device", Diagnostic.strong(service), MdnsClient.discoveryDataDiagnostics(data, kind));
+}
+
+function logNewAddresses(
+    service: string,
+    kind: string,
+    intf: string,
+    addresses: Map<string, MatterServerRecordWithExpire>,
+) {
+    logger.debug(
+        "Added",
+        addresses.size,
+        "addresses for",
+        Diagnostic.strong(service),
+        Diagnostic.dict({
+            kind,
+            addrs: MdnsClient.deviceAddressDiagnostics(addresses),
+            intf,
+        }),
+    );
+}

package/src/mdns/MdnsServer.ts

@@ -9,9 +9,12 @@ import {
     DnsMessageType,
     DnsRecord,
     DnsRecordType,
+    Instant,
     isDeepEqual,
     Logger,
     MatterAggregateError,
+    Millis,
+    Minutes,
     NetworkInterfaceDetails,
     ObserverGroup,
     Time,
@@ -38,7 +41,7 @@ export class MdnsServer {
 
             return serviceRecords;
         },
-        15 * 60 * 1000 /* 15mn - also matches maximum commissioning window time. */,
+        Minutes(15) /* matches maximum standard commissioning window time */,
     );
     readonly #recordLastSentAsMulticastAnswer = new Map<string, number>();
 
@@ -96,12 +99,13 @@ export class MdnsServer {
                 }
             }
 
-            const now = Time.nowMs();
+            const now = Time.nowMs;
             let uniCastResponse = queries.filter(query => !query.uniCastResponse).length === 0;
             const answersTimeSinceLastSent = answers.map(answer => ({
-                timeSinceLastMultiCast:
+                timeSinceLastMultiCast: Millis(
                     now - (this.#recordLastSentAsMulticastAnswer.get(this.buildDnsRecordKey(answer, sourceIntf)) ?? 0),
-                ttl: answer.ttl * 1000,
+                ),
+                ttl: answer.ttl,
             }));
             if (
                 uniCastResponse &&
@@ -112,7 +116,8 @@ export class MdnsServer {
             }
             if (!uniCastResponse) {
                 answers = answers.filter(
-                    (_, index) => answersTimeSinceLastSent[index].timeSinceLastMultiCast >= 900, // The last time sent as multicast was more than 900 ms ago
+                    // The last time sent as multicast was more than 900 ms ago
+                    (_, index) => answersTimeSinceLastSent[index].timeSinceLastMultiCast >= Millis(900),
                 );
                 if (answers.length === 0) continue; // Nothing to send
 
@@ -135,7 +140,7 @@ export class MdnsServer {
                 .catch(error => {
                     logger.warn(`Failed to send mDNS response to ${sourceIp}`, error);
                 });
-            await Time.sleep("MDNS delay", 20 + Math.floor(Math.random() * 100)); // as per DNS-SD spec wait 20-120ms before sending more packets
+            await Time.sleep("MDNS delay", Millis(20 + Math.floor(Math.random() * 100))); // as per DNS-SD spec wait 20-120ms before sending more packets
         }
     }
 
@@ -162,7 +167,7 @@ export class MdnsServer {
 
                     // TODO: try to combine the messages to avoid sending multiple messages but keep under 1500 bytes per message
                     await this.#announceRecordsForInterface(netInterface, serviceRecords);
-                    await Time.sleep("MDNS delay", 20 + Math.floor(Math.random() * 100)); // as per DNS-SD spec wait 20-120ms before sending more packets
+                    await Time.sleep("MDNS delay", Millis(20 + Math.floor(Math.random() * 100))); // as per DNS-SD spec wait 20-120ms before sending more packets
                 }
             }),
             "Error announcing MDNS messages",
@@ -177,7 +182,7 @@ export class MdnsServer {
                     if (services.length && !services.includes(service)) continue;
                     const instanceSet = new Set<string>();
                     serviceRecords.forEach(record => {
-                        record.ttl = 0;
+                        record.ttl = Instant;
                         if (record.recordType === DnsRecordType.TXT) {
                             instanceSet.add(record.name);
                         }
@@ -186,7 +191,7 @@ export class MdnsServer {
                     // TODO: try to combine the messages to avoid sending multiple messages but keep under 1500 bytes per message
                     await this.#announceRecordsForInterface(netInterface, serviceRecords);
                     this.#recordsGenerator.delete(service);
-                    await Time.sleep("MDNS delay", 20 + Math.floor(Math.random() * 100)); // as per DNS-SD spec wait 20-120ms before sending more packets
+                    await Time.sleep("MDNS delay", Millis(20 + Math.floor(Math.random() * 100))); // as per DNS-SD spec wait 20-120ms before sending more packets
                 }
             }),
             "Error happened when expiring MDNS announcements",

package/src/peer/ControllerCommissioner.ts

@@ -14,14 +14,17 @@ import {
     ChannelType,
     ClassExtends,
     Diagnostic,
+    Duration,
     Environment,
     Environmental,
     isIPv6,
     Logger,
+    Millis,
+    Minutes,
     NetInterfaceSet,
     NoResponseTimeoutError,
+    Seconds,
     ServerAddress,
-    serverAddressToString,
 } from "#general";
 import { InteractionClient, InteractionClientProvider } from "#interaction/InteractionClient.js";
 import { MdnsClient } from "#mdns/MdnsClient.js";
@@ -115,7 +118,7 @@ export interface DiscoveryAndCommissioningOptions extends CommissioningOptions {
         knownAddress?: ServerAddress;
 
         /** Timeout in seconds for the discovery process. Default: 30 seconds */
-        timeoutSeconds?: number;
+        timeout?: Duration;
     };
 }
 
@@ -179,7 +182,7 @@ export class ControllerCommissioner {
                 channel = await this.#initializePaseSecureChannel(address, passcode, discoveryData);
             } catch (e) {
                 NoResponseTimeoutError.accept(e);
-                logger.warn(`Could not connect to ${serverAddressToString(address)}: ${e.message}`);
+                logger.warn(`Could not connect to ${ServerAddress.urlFor(address)}: ${e.message}`);
             }
         }
 
@@ -197,7 +200,7 @@ export class ControllerCommissioner {
         options: DiscoveryAndCommissioningOptions,
     ): Promise<{ paseSecureChannel: MessageChannel; discoveryData?: DiscoveryData }> {
         const {
-            discovery: { timeoutSeconds = 30 },
+            discovery: { timeout = Seconds(30) },
             passcode,
         } = options;
 
@@ -256,7 +259,7 @@ export class ControllerCommissioner {
             const discoveredDevices = await ControllerDiscovery.discoverDeviceAddressesByIdentifier(
                 scannersToUse,
                 identifierData,
-                timeoutSeconds,
+                timeout,
             );
 
             const { result } = await ControllerDiscovery.iterateServerAddresses(
@@ -339,9 +342,9 @@ export class ControllerCommissioner {
         const unsecureSession = this.#context.sessions.createInsecureSession({
             // Use the session parameters from MDNS announcements when available and rest is assumed to be fallbacks
             sessionParameters: {
-                idleIntervalMs: device?.SII,
-                activeIntervalMs: device?.SAI,
-                activeThresholdMs: device?.SAT,
+                idleInterval: Millis(device?.SII),
+                activeInterval: Millis(device?.SAI),
+                activeThreshold: Millis(device?.SAT),
             },
             isInitiator: true,
         });
@@ -478,7 +481,7 @@ export class ControllerCommissioner {
                 return await this.#context.clients.connect(address, {
                     discoveryOptions: {
                         discoveryType: NodeDiscoveryType.TimedDiscovery,
-                        timeoutSeconds: 120,
+                        timeout: Minutes(2),
                         discoveryData,
                     },
                     allowUnknownPeer: true,